report.html

cupy/testing/_helper.py:1175: in test_func
impl(self, *args, **kw)
cupy/testing/_helper.py:825: in test_func
impl(self, *args, **kw)
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:648: in check_func
_array.assert_array_equal(x, y, err_msg, verbose, strides_check)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

x = array([0, 1], dtype=int32), y = array([0, 1], dtype=int32), err_msg = ''
verbose = True, strides_check = True

def assert_array_equal(x, y, err_msg='', verbose=True, strides_check=False):
"""Raises an AssertionError if two array_like objects are not equal.

Args:
x(numpy.ndarray or cupy.ndarray): The actual object to check.
y(numpy.ndarray or cupy.ndarray): The desired, expected object.
strides_check(bool): If ``True``, consistency of strides is also
checked.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting values
are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_array_equal`
"""
> numpy.testing.assert_array_equal(
cupy.asnumpy(x), cupy.asnumpy(y), err_msg=err_msg,
verbose=verbose)
E AssertionError:
E Arrays are not equal
E
E Mismatched elements: 1 / 2 (50%)
E Max absolute difference: 1065353215
E Max relative difference: 1.06535322e+09
E x: array([ 0, 1065353216], dtype=int32)
E y: array([0, 1], dtype=int32)

cupy/testing/_array.py:91: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.int32'> order is C

self = <<cupy_tests.random_tests.test_distributions.TestDistributionsGamma_param_0_{dtype=float64, scale_shape=(), shape=(4, ...ma_generator> parameter: {'dtype': <class 'numpy.float64'>, 'scale_shape': (), 'shape': (4, 3, 2), 'shape_shape': ()}>
shape_dtype = <class 'numpy.float16'>, scale_dtype = <class 'numpy.float16'>

@cupy.testing.for_dtypes_combination(
_float_dtypes, names=['shape_dtype', 'scale_dtype'])
def test_gamma_generator(self, shape_dtype, scale_dtype):
> self.check_distribution(cupy.random.default_rng().gamma,
shape_dtype, scale_dtype)

tests/cupy_tests/random_tests/test_distributions.py:195:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

seed = None

def default_rng(seed=None): # NOQA avoid redefinition of seed
"""Construct a new Generator with the default BitGenerator (XORWOW).

Args:
seed (None, int, array_like[ints], numpy.random.SeedSequence, cupy.random.BitGenerator, cupy.random.Generator, optional):
A seed to initialize the :class:`cupy.random.BitGenerator`. If an
``int`` or ``array_like[ints]`` or None is passed, then it will be
passed to :class:`numpy.random.SeedSequence` to detive the initial
:class:`BitGenerator` state. One may also pass in a `SeedSequence
instance. Adiditionally, when passed :class:`BitGenerator`, it will
be wrapped by :class:`Generator`. If passed a :class:`Generator`,
it will be returned unaltered.

Returns:
Generator: The initialized generator object.
""" # NOQA, list of types need to be in one line for sphinx
if runtime.is_hip:
> raise RuntimeError('Generator API not supported in HIP,'
' please use the legacy one.')
E RuntimeError: Generator API not supported in HIP, please use the legacy one.

cupy/random/__init__.py:36: RuntimeError
------------------------------Captured stdout call------------------------------
{'shape_dtype': <class 'numpy.float16'>, 'scale_dtype': <class 'numpy.float16'>}

self = <<cupy_tests.random_tests.test_distributions.TestDistributionsGamma_param_1_{dtype=float64, scale_shape=(), shape=(4, ...enerator> parameter: {'dtype': <class 'numpy.float64'>, 'scale_shape': (), 'shape': (4, 3, 2), 'shape_shape': (3, 2)}>
shape_dtype = <class 'numpy.float16'>, scale_dtype = <class 'numpy.float16'>

@cupy.testing.for_dtypes_combination(
_float_dtypes, names=['shape_dtype', 'scale_dtype'])
def test_gamma_generator(self, shape_dtype, scale_dtype):
> self.check_distribution(cupy.random.default_rng().gamma,
shape_dtype, scale_dtype)

tests/cupy_tests/random_tests/test_distributions.py:195:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

seed = None

def default_rng(seed=None): # NOQA avoid redefinition of seed
"""Construct a new Generator with the default BitGenerator (XORWOW).

Args:
seed (None, int, array_like[ints], numpy.random.SeedSequence, cupy.random.BitGenerator, cupy.random.Generator, optional):
A seed to initialize the :class:`cupy.random.BitGenerator`. If an
``int`` or ``array_like[ints]`` or None is passed, then it will be
passed to :class:`numpy.random.SeedSequence` to detive the initial
:class:`BitGenerator` state. One may also pass in a `SeedSequence
instance. Adiditionally, when passed :class:`BitGenerator`, it will
be wrapped by :class:`Generator`. If passed a :class:`Generator`,
it will be returned unaltered.

Returns:
Generator: The initialized generator object.
""" # NOQA, list of types need to be in one line for sphinx
if runtime.is_hip:
> raise RuntimeError('Generator API not supported in HIP,'
' please use the legacy one.')
E RuntimeError: Generator API not supported in HIP, please use the legacy one.

cupy/random/__init__.py:36: RuntimeError
------------------------------Captured stdout call------------------------------
{'shape_dtype': <class 'numpy.float16'>, 'scale_dtype': <class 'numpy.float16'>}

self = <<cupy_tests.random_tests.test_distributions.TestDistributionsGamma_param_2_{dtype=float64, scale_shape=(), shape=(3, ...gamma_generator> parameter: {'dtype': <class 'numpy.float64'>, 'scale_shape': (), 'shape': (3, 2), 'shape_shape': ()}>
shape_dtype = <class 'numpy.float16'>, scale_dtype = <class 'numpy.float16'>

@cupy.testing.for_dtypes_combination(
_float_dtypes, names=['shape_dtype', 'scale_dtype'])
def test_gamma_generator(self, shape_dtype, scale_dtype):
> self.check_distribution(cupy.random.default_rng().gamma,
shape_dtype, scale_dtype)

tests/cupy_tests/random_tests/test_distributions.py:195:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

seed = None

def default_rng(seed=None): # NOQA avoid redefinition of seed
"""Construct a new Generator with the default BitGenerator (XORWOW).

Args:
seed (None, int, array_like[ints], numpy.random.SeedSequence, cupy.random.BitGenerator, cupy.random.Generator, optional):
A seed to initialize the :class:`cupy.random.BitGenerator`. If an
``int`` or ``array_like[ints]`` or None is passed, then it will be
passed to :class:`numpy.random.SeedSequence` to detive the initial
:class:`BitGenerator` state. One may also pass in a `SeedSequence
instance. Adiditionally, when passed :class:`BitGenerator`, it will
be wrapped by :class:`Generator`. If passed a :class:`Generator`,
it will be returned unaltered.

Returns:
Generator: The initialized generator object.
""" # NOQA, list of types need to be in one line for sphinx
if runtime.is_hip:
> raise RuntimeError('Generator API not supported in HIP,'
' please use the legacy one.')
E RuntimeError: Generator API not supported in HIP, please use the legacy one.

cupy/random/__init__.py:36: RuntimeError
------------------------------Captured stdout call------------------------------
{'shape_dtype': <class 'numpy.float16'>, 'scale_dtype': <class 'numpy.float16'>}

self = <<cupy_tests.random_tests.test_distributions.TestDistributionsGamma_param_3_{dtype=float64, scale_shape=(), shape=(3, ...a_generator> parameter: {'dtype': <class 'numpy.float64'>, 'scale_shape': (), 'shape': (3, 2), 'shape_shape': (3, 2)}>
shape_dtype = <class 'numpy.float16'>, scale_dtype = <class 'numpy.float16'>

@cupy.testing.for_dtypes_combination(
_float_dtypes, names=['shape_dtype', 'scale_dtype'])
def test_gamma_generator(self, shape_dtype, scale_dtype):
> self.check_distribution(cupy.random.default_rng().gamma,
shape_dtype, scale_dtype)

tests/cupy_tests/random_tests/test_distributions.py:195:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

seed = None

def default_rng(seed=None): # NOQA avoid redefinition of seed
"""Construct a new Generator with the default BitGenerator (XORWOW).

Args:
seed (None, int, array_like[ints], numpy.random.SeedSequence, cupy.random.BitGenerator, cupy.random.Generator, optional):
A seed to initialize the :class:`cupy.random.BitGenerator`. If an
``int`` or ``array_like[ints]`` or None is passed, then it will be
passed to :class:`numpy.random.SeedSequence` to detive the initial
:class:`BitGenerator` state. One may also pass in a `SeedSequence
instance. Adiditionally, when passed :class:`BitGenerator`, it will
be wrapped by :class:`Generator`. If passed a :class:`Generator`,
it will be returned unaltered.

Returns:
Generator: The initialized generator object.
""" # NOQA, list of types need to be in one line for sphinx
if runtime.is_hip:
> raise RuntimeError('Generator API not supported in HIP,'
' please use the legacy one.')
E RuntimeError: Generator API not supported in HIP, please use the legacy one.

cupy/random/__init__.py:36: RuntimeError
------------------------------Captured stdout call------------------------------
{'shape_dtype': <class 'numpy.float16'>, 'scale_dtype': <class 'numpy.float16'>}

self = <<cupy_tests.random_tests.test_distributions.TestDistributionsGamma_param_4_{dtype=float64, scale_shape=(3, 2), shape=...enerator> parameter: {'dtype': <class 'numpy.float64'>, 'scale_shape': (3, 2), 'shape': (4, 3, 2), 'shape_shape': ()}>
shape_dtype = <class 'numpy.float16'>, scale_dtype = <class 'numpy.float16'>

@cupy.testing.for_dtypes_combination(
_float_dtypes, names=['shape_dtype', 'scale_dtype'])
def test_gamma_generator(self, shape_dtype, scale_dtype):
> self.check_distribution(cupy.random.default_rng().gamma,
shape_dtype, scale_dtype)

tests/cupy_tests/random_tests/test_distributions.py:195:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

seed = None

def default_rng(seed=None): # NOQA avoid redefinition of seed
"""Construct a new Generator with the default BitGenerator (XORWOW).

Args:
seed (None, int, array_like[ints], numpy.random.SeedSequence, cupy.random.BitGenerator, cupy.random.Generator, optional):
A seed to initialize the :class:`cupy.random.BitGenerator`. If an
``int`` or ``array_like[ints]`` or None is passed, then it will be
passed to :class:`numpy.random.SeedSequence` to detive the initial
:class:`BitGenerator` state. One may also pass in a `SeedSequence
instance. Adiditionally, when passed :class:`BitGenerator`, it will
be wrapped by :class:`Generator`. If passed a :class:`Generator`,
it will be returned unaltered.

Returns:
Generator: The initialized generator object.
""" # NOQA, list of types need to be in one line for sphinx
if runtime.is_hip:
> raise RuntimeError('Generator API not supported in HIP,'
' please use the legacy one.')
E RuntimeError: Generator API not supported in HIP, please use the legacy one.

cupy/random/__init__.py:36: RuntimeError
------------------------------Captured stdout call------------------------------
{'shape_dtype': <class 'numpy.float16'>, 'scale_dtype': <class 'numpy.float16'>}

self = <<cupy_tests.random_tests.test_distributions.TestDistributionsGamma_param_5_{dtype=float64, scale_shape=(3, 2), shape=...ator> parameter: {'dtype': <class 'numpy.float64'>, 'scale_shape': (3, 2), 'shape': (4, 3, 2), 'shape_shape': (3, 2)}>
shape_dtype = <class 'numpy.float16'>, scale_dtype = <class 'numpy.float16'>

@cupy.testing.for_dtypes_combination(
_float_dtypes, names=['shape_dtype', 'scale_dtype'])
def test_gamma_generator(self, shape_dtype, scale_dtype):
> self.check_distribution(cupy.random.default_rng().gamma,
shape_dtype, scale_dtype)

tests/cupy_tests/random_tests/test_distributions.py:195:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

seed = None

def default_rng(seed=None): # NOQA avoid redefinition of seed
"""Construct a new Generator with the default BitGenerator (XORWOW).

Args:
seed (None, int, array_like[ints], numpy.random.SeedSequence, cupy.random.BitGenerator, cupy.random.Generator, optional):
A seed to initialize the :class:`cupy.random.BitGenerator`. If an
``int`` or ``array_like[ints]`` or None is passed, then it will be
passed to :class:`numpy.random.SeedSequence` to detive the initial
:class:`BitGenerator` state. One may also pass in a `SeedSequence
instance. Adiditionally, when passed :class:`BitGenerator`, it will
be wrapped by :class:`Generator`. If passed a :class:`Generator`,
it will be returned unaltered.

Returns:
Generator: The initialized generator object.
""" # NOQA, list of types need to be in one line for sphinx
if runtime.is_hip:
> raise RuntimeError('Generator API not supported in HIP,'
' please use the legacy one.')
E RuntimeError: Generator API not supported in HIP, please use the legacy one.

cupy/random/__init__.py:36: RuntimeError
------------------------------Captured stdout call------------------------------
{'shape_dtype': <class 'numpy.float16'>, 'scale_dtype': <class 'numpy.float16'>}

self = <<cupy_tests.random_tests.test_distributions.TestDistributionsGamma_param_6_{dtype=float64, scale_shape=(3, 2), shape=...a_generator> parameter: {'dtype': <class 'numpy.float64'>, 'scale_shape': (3, 2), 'shape': (3, 2), 'shape_shape': ()}>
shape_dtype = <class 'numpy.float16'>, scale_dtype = <class 'numpy.float16'>

@cupy.testing.for_dtypes_combination(
_float_dtypes, names=['shape_dtype', 'scale_dtype'])
def test_gamma_generator(self, shape_dtype, scale_dtype):
> self.check_distribution(cupy.random.default_rng().gamma,
shape_dtype, scale_dtype)

tests/cupy_tests/random_tests/test_distributions.py:195:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

seed = None

def default_rng(seed=None): # NOQA avoid redefinition of seed
"""Construct a new Generator with the default BitGenerator (XORWOW).

Args:
seed (None, int, array_like[ints], numpy.random.SeedSequence, cupy.random.BitGenerator, cupy.random.Generator, optional):
A seed to initialize the :class:`cupy.random.BitGenerator`. If an
``int`` or ``array_like[ints]`` or None is passed, then it will be
passed to :class:`numpy.random.SeedSequence` to detive the initial
:class:`BitGenerator` state. One may also pass in a `SeedSequence
instance. Adiditionally, when passed :class:`BitGenerator`, it will
be wrapped by :class:`Generator`. If passed a :class:`Generator`,
it will be returned unaltered.

Returns:
Generator: The initialized generator object.
""" # NOQA, list of types need to be in one line for sphinx
if runtime.is_hip:
> raise RuntimeError('Generator API not supported in HIP,'
' please use the legacy one.')
E RuntimeError: Generator API not supported in HIP, please use the legacy one.

cupy/random/__init__.py:36: RuntimeError
------------------------------Captured stdout call------------------------------
{'shape_dtype': <class 'numpy.float16'>, 'scale_dtype': <class 'numpy.float16'>}

self = <<cupy_tests.random_tests.test_distributions.TestDistributionsGamma_param_7_{dtype=float64, scale_shape=(3, 2), shape=...nerator> parameter: {'dtype': <class 'numpy.float64'>, 'scale_shape': (3, 2), 'shape': (3, 2), 'shape_shape': (3, 2)}>
shape_dtype = <class 'numpy.float16'>, scale_dtype = <class 'numpy.float16'>

@cupy.testing.for_dtypes_combination(
_float_dtypes, names=['shape_dtype', 'scale_dtype'])
def test_gamma_generator(self, shape_dtype, scale_dtype):
> self.check_distribution(cupy.random.default_rng().gamma,
shape_dtype, scale_dtype)

tests/cupy_tests/random_tests/test_distributions.py:195:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

seed = None

def default_rng(seed=None): # NOQA avoid redefinition of seed
"""Construct a new Generator with the default BitGenerator (XORWOW).

Args:
seed (None, int, array_like[ints], numpy.random.SeedSequence, cupy.random.BitGenerator, cupy.random.Generator, optional):
A seed to initialize the :class:`cupy.random.BitGenerator`. If an
``int`` or ``array_like[ints]`` or None is passed, then it will be
passed to :class:`numpy.random.SeedSequence` to detive the initial
:class:`BitGenerator` state. One may also pass in a `SeedSequence
instance. Adiditionally, when passed :class:`BitGenerator`, it will
be wrapped by :class:`Generator`. If passed a :class:`Generator`,
it will be returned unaltered.

Returns:
Generator: The initialized generator object.
""" # NOQA, list of types need to be in one line for sphinx
if runtime.is_hip:
> raise RuntimeError('Generator API not supported in HIP,'
' please use the legacy one.')
E RuntimeError: Generator API not supported in HIP, please use the legacy one.

cupy/random/__init__.py:36: RuntimeError
------------------------------Captured stdout call------------------------------
{'shape_dtype': <class 'numpy.float16'>, 'scale_dtype': <class 'numpy.float16'>}

self = <<cupy_tests.random_tests.test_distributions.TestDistributionsGamma_param_8_{dtype=float32, scale_shape=(), shape=(4, ...ma_generator> parameter: {'dtype': <class 'numpy.float32'>, 'scale_shape': (), 'shape': (4, 3, 2), 'shape_shape': ()}>
shape_dtype = <class 'numpy.float16'>, scale_dtype = <class 'numpy.float16'>

@cupy.testing.for_dtypes_combination(
_float_dtypes, names=['shape_dtype', 'scale_dtype'])
def test_gamma_generator(self, shape_dtype, scale_dtype):
> self.check_distribution(cupy.random.default_rng().gamma,
shape_dtype, scale_dtype)

tests/cupy_tests/random_tests/test_distributions.py:195:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

seed = None

def default_rng(seed=None): # NOQA avoid redefinition of seed
"""Construct a new Generator with the default BitGenerator (XORWOW).

Args:
seed (None, int, array_like[ints], numpy.random.SeedSequence, cupy.random.BitGenerator, cupy.random.Generator, optional):
A seed to initialize the :class:`cupy.random.BitGenerator`. If an
``int`` or ``array_like[ints]`` or None is passed, then it will be
passed to :class:`numpy.random.SeedSequence` to detive the initial
:class:`BitGenerator` state. One may also pass in a `SeedSequence
instance. Adiditionally, when passed :class:`BitGenerator`, it will
be wrapped by :class:`Generator`. If passed a :class:`Generator`,
it will be returned unaltered.

Returns:
Generator: The initialized generator object.
""" # NOQA, list of types need to be in one line for sphinx
if runtime.is_hip:
> raise RuntimeError('Generator API not supported in HIP,'
' please use the legacy one.')
E RuntimeError: Generator API not supported in HIP, please use the legacy one.

cupy/random/__init__.py:36: RuntimeError
------------------------------Captured stdout call------------------------------
{'shape_dtype': <class 'numpy.float16'>, 'scale_dtype': <class 'numpy.float16'>}

self = <<cupy_tests.random_tests.test_distributions.TestDistributionsGamma_param_9_{dtype=float32, scale_shape=(), shape=(4, ...enerator> parameter: {'dtype': <class 'numpy.float32'>, 'scale_shape': (), 'shape': (4, 3, 2), 'shape_shape': (3, 2)}>
shape_dtype = <class 'numpy.float16'>, scale_dtype = <class 'numpy.float16'>

@cupy.testing.for_dtypes_combination(
_float_dtypes, names=['shape_dtype', 'scale_dtype'])
def test_gamma_generator(self, shape_dtype, scale_dtype):
> self.check_distribution(cupy.random.default_rng().gamma,
shape_dtype, scale_dtype)

tests/cupy_tests/random_tests/test_distributions.py:195:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

seed = None

def default_rng(seed=None): # NOQA avoid redefinition of seed
"""Construct a new Generator with the default BitGenerator (XORWOW).

Args:
seed (None, int, array_like[ints], numpy.random.SeedSequence, cupy.random.BitGenerator, cupy.random.Generator, optional):
A seed to initialize the :class:`cupy.random.BitGenerator`. If an
``int`` or ``array_like[ints]`` or None is passed, then it will be
passed to :class:`numpy.random.SeedSequence` to detive the initial
:class:`BitGenerator` state. One may also pass in a `SeedSequence
instance. Adiditionally, when passed :class:`BitGenerator`, it will
be wrapped by :class:`Generator`. If passed a :class:`Generator`,
it will be returned unaltered.

Returns:
Generator: The initialized generator object.
""" # NOQA, list of types need to be in one line for sphinx
if runtime.is_hip:
> raise RuntimeError('Generator API not supported in HIP,'
' please use the legacy one.')
E RuntimeError: Generator API not supported in HIP, please use the legacy one.

cupy/random/__init__.py:36: RuntimeError
------------------------------Captured stdout call------------------------------
{'shape_dtype': <class 'numpy.float16'>, 'scale_dtype': <class 'numpy.float16'>}

self = <<cupy_tests.random_tests.test_distributions.TestDistributionsGamma_param_10_{dtype=float32, scale_shape=(), shape=(3,...gamma_generator> parameter: {'dtype': <class 'numpy.float32'>, 'scale_shape': (), 'shape': (3, 2), 'shape_shape': ()}>
shape_dtype = <class 'numpy.float16'>, scale_dtype = <class 'numpy.float16'>

@cupy.testing.for_dtypes_combination(
_float_dtypes, names=['shape_dtype', 'scale_dtype'])
def test_gamma_generator(self, shape_dtype, scale_dtype):
> self.check_distribution(cupy.random.default_rng().gamma,
shape_dtype, scale_dtype)

tests/cupy_tests/random_tests/test_distributions.py:195:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

seed = None

def default_rng(seed=None): # NOQA avoid redefinition of seed
"""Construct a new Generator with the default BitGenerator (XORWOW).

Args:
seed (None, int, array_like[ints], numpy.random.SeedSequence, cupy.random.BitGenerator, cupy.random.Generator, optional):
A seed to initialize the :class:`cupy.random.BitGenerator`. If an
``int`` or ``array_like[ints]`` or None is passed, then it will be
passed to :class:`numpy.random.SeedSequence` to detive the initial
:class:`BitGenerator` state. One may also pass in a `SeedSequence
instance. Adiditionally, when passed :class:`BitGenerator`, it will
be wrapped by :class:`Generator`. If passed a :class:`Generator`,
it will be returned unaltered.

Returns:
Generator: The initialized generator object.
""" # NOQA, list of types need to be in one line for sphinx
if runtime.is_hip:
> raise RuntimeError('Generator API not supported in HIP,'
' please use the legacy one.')
E RuntimeError: Generator API not supported in HIP, please use the legacy one.

cupy/random/__init__.py:36: RuntimeError
------------------------------Captured stdout call------------------------------
{'shape_dtype': <class 'numpy.float16'>, 'scale_dtype': <class 'numpy.float16'>}

self = <<cupy_tests.random_tests.test_distributions.TestDistributionsGamma_param_11_{dtype=float32, scale_shape=(), shape=(3,...a_generator> parameter: {'dtype': <class 'numpy.float32'>, 'scale_shape': (), 'shape': (3, 2), 'shape_shape': (3, 2)}>
shape_dtype = <class 'numpy.float16'>, scale_dtype = <class 'numpy.float16'>

@cupy.testing.for_dtypes_combination(
_float_dtypes, names=['shape_dtype', 'scale_dtype'])
def test_gamma_generator(self, shape_dtype, scale_dtype):
> self.check_distribution(cupy.random.default_rng().gamma,
shape_dtype, scale_dtype)

tests/cupy_tests/random_tests/test_distributions.py:195:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

seed = None

def default_rng(seed=None): # NOQA avoid redefinition of seed
"""Construct a new Generator with the default BitGenerator (XORWOW).

Args:
seed (None, int, array_like[ints], numpy.random.SeedSequence, cupy.random.BitGenerator, cupy.random.Generator, optional):
A seed to initialize the :class:`cupy.random.BitGenerator`. If an
``int`` or ``array_like[ints]`` or None is passed, then it will be
passed to :class:`numpy.random.SeedSequence` to detive the initial
:class:`BitGenerator` state. One may also pass in a `SeedSequence
instance. Adiditionally, when passed :class:`BitGenerator`, it will
be wrapped by :class:`Generator`. If passed a :class:`Generator`,
it will be returned unaltered.

Returns:
Generator: The initialized generator object.
""" # NOQA, list of types need to be in one line for sphinx
if runtime.is_hip:
> raise RuntimeError('Generator API not supported in HIP,'
' please use the legacy one.')
E RuntimeError: Generator API not supported in HIP, please use the legacy one.

cupy/random/__init__.py:36: RuntimeError
------------------------------Captured stdout call------------------------------
{'shape_dtype': <class 'numpy.float16'>, 'scale_dtype': <class 'numpy.float16'>}

self = <<cupy_tests.random_tests.test_distributions.TestDistributionsGamma_param_12_{dtype=float32, scale_shape=(3, 2), shape...enerator> parameter: {'dtype': <class 'numpy.float32'>, 'scale_shape': (3, 2), 'shape': (4, 3, 2), 'shape_shape': ()}>
shape_dtype = <class 'numpy.float16'>, scale_dtype = <class 'numpy.float16'>

@cupy.testing.for_dtypes_combination(
_float_dtypes, names=['shape_dtype', 'scale_dtype'])
def test_gamma_generator(self, shape_dtype, scale_dtype):
> self.check_distribution(cupy.random.default_rng().gamma,
shape_dtype, scale_dtype)

tests/cupy_tests/random_tests/test_distributions.py:195:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

seed = None

def default_rng(seed=None): # NOQA avoid redefinition of seed
"""Construct a new Generator with the default BitGenerator (XORWOW).

Args:
seed (None, int, array_like[ints], numpy.random.SeedSequence, cupy.random.BitGenerator, cupy.random.Generator, optional):
A seed to initialize the :class:`cupy.random.BitGenerator`. If an
``int`` or ``array_like[ints]`` or None is passed, then it will be
passed to :class:`numpy.random.SeedSequence` to detive the initial
:class:`BitGenerator` state. One may also pass in a `SeedSequence
instance. Adiditionally, when passed :class:`BitGenerator`, it will
be wrapped by :class:`Generator`. If passed a :class:`Generator`,
it will be returned unaltered.

Returns:
Generator: The initialized generator object.
""" # NOQA, list of types need to be in one line for sphinx
if runtime.is_hip:
> raise RuntimeError('Generator API not supported in HIP,'
' please use the legacy one.')
E RuntimeError: Generator API not supported in HIP, please use the legacy one.

cupy/random/__init__.py:36: RuntimeError
------------------------------Captured stdout call------------------------------
{'shape_dtype': <class 'numpy.float16'>, 'scale_dtype': <class 'numpy.float16'>}

self = <<cupy_tests.random_tests.test_distributions.TestDistributionsGamma_param_13_{dtype=float32, scale_shape=(3, 2), shape...ator> parameter: {'dtype': <class 'numpy.float32'>, 'scale_shape': (3, 2), 'shape': (4, 3, 2), 'shape_shape': (3, 2)}>
shape_dtype = <class 'numpy.float16'>, scale_dtype = <class 'numpy.float16'>

@cupy.testing.for_dtypes_combination(
_float_dtypes, names=['shape_dtype', 'scale_dtype'])
def test_gamma_generator(self, shape_dtype, scale_dtype):
> self.check_distribution(cupy.random.default_rng().gamma,
shape_dtype, scale_dtype)

tests/cupy_tests/random_tests/test_distributions.py:195:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

seed = None

def default_rng(seed=None): # NOQA avoid redefinition of seed
"""Construct a new Generator with the default BitGenerator (XORWOW).

Args:
seed (None, int, array_like[ints], numpy.random.SeedSequence, cupy.random.BitGenerator, cupy.random.Generator, optional):
A seed to initialize the :class:`cupy.random.BitGenerator`. If an
``int`` or ``array_like[ints]`` or None is passed, then it will be
passed to :class:`numpy.random.SeedSequence` to detive the initial
:class:`BitGenerator` state. One may also pass in a `SeedSequence
instance. Adiditionally, when passed :class:`BitGenerator`, it will
be wrapped by :class:`Generator`. If passed a :class:`Generator`,
it will be returned unaltered.

Returns:
Generator: The initialized generator object.
""" # NOQA, list of types need to be in one line for sphinx
if runtime.is_hip:
> raise RuntimeError('Generator API not supported in HIP,'
' please use the legacy one.')
E RuntimeError: Generator API not supported in HIP, please use the legacy one.

cupy/random/__init__.py:36: RuntimeError
------------------------------Captured stdout call------------------------------
{'shape_dtype': <class 'numpy.float16'>, 'scale_dtype': <class 'numpy.float16'>}

self = <<cupy_tests.random_tests.test_distributions.TestDistributionsGamma_param_14_{dtype=float32, scale_shape=(3, 2), shape...a_generator> parameter: {'dtype': <class 'numpy.float32'>, 'scale_shape': (3, 2), 'shape': (3, 2), 'shape_shape': ()}>
shape_dtype = <class 'numpy.float16'>, scale_dtype = <class 'numpy.float16'>

@cupy.testing.for_dtypes_combination(
_float_dtypes, names=['shape_dtype', 'scale_dtype'])
def test_gamma_generator(self, shape_dtype, scale_dtype):
> self.check_distribution(cupy.random.default_rng().gamma,
shape_dtype, scale_dtype)

tests/cupy_tests/random_tests/test_distributions.py:195:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

seed = None

def default_rng(seed=None): # NOQA avoid redefinition of seed
"""Construct a new Generator with the default BitGenerator (XORWOW).

Args:
seed (None, int, array_like[ints], numpy.random.SeedSequence, cupy.random.BitGenerator, cupy.random.Generator, optional):
A seed to initialize the :class:`cupy.random.BitGenerator`. If an
``int`` or ``array_like[ints]`` or None is passed, then it will be
passed to :class:`numpy.random.SeedSequence` to detive the initial
:class:`BitGenerator` state. One may also pass in a `SeedSequence
instance. Adiditionally, when passed :class:`BitGenerator`, it will
be wrapped by :class:`Generator`. If passed a :class:`Generator`,
it will be returned unaltered.

Returns:
Generator: The initialized generator object.
""" # NOQA, list of types need to be in one line for sphinx
if runtime.is_hip:
> raise RuntimeError('Generator API not supported in HIP,'
' please use the legacy one.')
E RuntimeError: Generator API not supported in HIP, please use the legacy one.

cupy/random/__init__.py:36: RuntimeError
------------------------------Captured stdout call------------------------------
{'shape_dtype': <class 'numpy.float16'>, 'scale_dtype': <class 'numpy.float16'>}

self = <<cupy_tests.random_tests.test_distributions.TestDistributionsGamma_param_15_{dtype=float32, scale_shape=(3, 2), shape...nerator> parameter: {'dtype': <class 'numpy.float32'>, 'scale_shape': (3, 2), 'shape': (3, 2), 'shape_shape': (3, 2)}>
shape_dtype = <class 'numpy.float16'>, scale_dtype = <class 'numpy.float16'>

@cupy.testing.for_dtypes_combination(
_float_dtypes, names=['shape_dtype', 'scale_dtype'])
def test_gamma_generator(self, shape_dtype, scale_dtype):
> self.check_distribution(cupy.random.default_rng().gamma,
shape_dtype, scale_dtype)

tests/cupy_tests/random_tests/test_distributions.py:195:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

seed = None

def default_rng(seed=None): # NOQA avoid redefinition of seed
"""Construct a new Generator with the default BitGenerator (XORWOW).

Args:
seed (None, int, array_like[ints], numpy.random.SeedSequence, cupy.random.BitGenerator, cupy.random.Generator, optional):
A seed to initialize the :class:`cupy.random.BitGenerator`. If an
``int`` or ``array_like[ints]`` or None is passed, then it will be
passed to :class:`numpy.random.SeedSequence` to detive the initial
:class:`BitGenerator` state. One may also pass in a `SeedSequence
instance. Adiditionally, when passed :class:`BitGenerator`, it will
be wrapped by :class:`Generator`. If passed a :class:`Generator`,
it will be returned unaltered.

Returns:
Generator: The initialized generator object.
""" # NOQA, list of types need to be in one line for sphinx
if runtime.is_hip:
> raise RuntimeError('Generator API not supported in HIP,'
' please use the legacy one.')
E RuntimeError: Generator API not supported in HIP, please use the legacy one.

cupy/random/__init__.py:36: RuntimeError
------------------------------Captured stdout call------------------------------
{'shape_dtype': <class 'numpy.float16'>, 'scale_dtype': <class 'numpy.float16'>}

self = <<cupy_tests.random_tests.test_distributions.TestDistributionsGamma_param_16_{dtype=float16, scale_shape=(), shape=(4,...ma_generator> parameter: {'dtype': <class 'numpy.float16'>, 'scale_shape': (), 'shape': (4, 3, 2), 'shape_shape': ()}>
shape_dtype = <class 'numpy.float16'>, scale_dtype = <class 'numpy.float16'>

@cupy.testing.for_dtypes_combination(
_float_dtypes, names=['shape_dtype', 'scale_dtype'])
def test_gamma_generator(self, shape_dtype, scale_dtype):
> self.check_distribution(cupy.random.default_rng().gamma,
shape_dtype, scale_dtype)

tests/cupy_tests/random_tests/test_distributions.py:195:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

seed = None

def default_rng(seed=None): # NOQA avoid redefinition of seed
"""Construct a new Generator with the default BitGenerator (XORWOW).

Args:
seed (None, int, array_like[ints], numpy.random.SeedSequence, cupy.random.BitGenerator, cupy.random.Generator, optional):
A seed to initialize the :class:`cupy.random.BitGenerator`. If an
``int`` or ``array_like[ints]`` or None is passed, then it will be
passed to :class:`numpy.random.SeedSequence` to detive the initial
:class:`BitGenerator` state. One may also pass in a `SeedSequence
instance. Adiditionally, when passed :class:`BitGenerator`, it will
be wrapped by :class:`Generator`. If passed a :class:`Generator`,
it will be returned unaltered.

Returns:
Generator: The initialized generator object.
""" # NOQA, list of types need to be in one line for sphinx
if runtime.is_hip:
> raise RuntimeError('Generator API not supported in HIP,'
' please use the legacy one.')
E RuntimeError: Generator API not supported in HIP, please use the legacy one.

cupy/random/__init__.py:36: RuntimeError
------------------------------Captured stdout call------------------------------
{'shape_dtype': <class 'numpy.float16'>, 'scale_dtype': <class 'numpy.float16'>}

self = <<cupy_tests.random_tests.test_distributions.TestDistributionsGamma_param_17_{dtype=float16, scale_shape=(), shape=(4,...enerator> parameter: {'dtype': <class 'numpy.float16'>, 'scale_shape': (), 'shape': (4, 3, 2), 'shape_shape': (3, 2)}>
shape_dtype = <class 'numpy.float16'>, scale_dtype = <class 'numpy.float16'>

@cupy.testing.for_dtypes_combination(
_float_dtypes, names=['shape_dtype', 'scale_dtype'])
def test_gamma_generator(self, shape_dtype, scale_dtype):
> self.check_distribution(cupy.random.default_rng().gamma,
shape_dtype, scale_dtype)

tests/cupy_tests/random_tests/test_distributions.py:195:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

seed = None

def default_rng(seed=None): # NOQA avoid redefinition of seed
"""Construct a new Generator with the default BitGenerator (XORWOW).

Args:
seed (None, int, array_like[ints], numpy.random.SeedSequence, cupy.random.BitGenerator, cupy.random.Generator, optional):
A seed to initialize the :class:`cupy.random.BitGenerator`. If an
``int`` or ``array_like[ints]`` or None is passed, then it will be
passed to :class:`numpy.random.SeedSequence` to detive the initial
:class:`BitGenerator` state. One may also pass in a `SeedSequence
instance. Adiditionally, when passed :class:`BitGenerator`, it will
be wrapped by :class:`Generator`. If passed a :class:`Generator`,
it will be returned unaltered.

Returns:
Generator: The initialized generator object.
""" # NOQA, list of types need to be in one line for sphinx
if runtime.is_hip:
> raise RuntimeError('Generator API not supported in HIP,'
' please use the legacy one.')
E RuntimeError: Generator API not supported in HIP, please use the legacy one.

cupy/random/__init__.py:36: RuntimeError
------------------------------Captured stdout call------------------------------
{'shape_dtype': <class 'numpy.float16'>, 'scale_dtype': <class 'numpy.float16'>}

self = <<cupy_tests.random_tests.test_distributions.TestDistributionsGamma_param_18_{dtype=float16, scale_shape=(), shape=(3,...gamma_generator> parameter: {'dtype': <class 'numpy.float16'>, 'scale_shape': (), 'shape': (3, 2), 'shape_shape': ()}>
shape_dtype = <class 'numpy.float16'>, scale_dtype = <class 'numpy.float16'>

@cupy.testing.for_dtypes_combination(
_float_dtypes, names=['shape_dtype', 'scale_dtype'])
def test_gamma_generator(self, shape_dtype, scale_dtype):
> self.check_distribution(cupy.random.default_rng().gamma,
shape_dtype, scale_dtype)

tests/cupy_tests/random_tests/test_distributions.py:195:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

seed = None

def default_rng(seed=None): # NOQA avoid redefinition of seed
"""Construct a new Generator with the default BitGenerator (XORWOW).

Args:
seed (None, int, array_like[ints], numpy.random.SeedSequence, cupy.random.BitGenerator, cupy.random.Generator, optional):
A seed to initialize the :class:`cupy.random.BitGenerator`. If an
``int`` or ``array_like[ints]`` or None is passed, then it will be
passed to :class:`numpy.random.SeedSequence` to detive the initial
:class:`BitGenerator` state. One may also pass in a `SeedSequence
instance. Adiditionally, when passed :class:`BitGenerator`, it will
be wrapped by :class:`Generator`. If passed a :class:`Generator`,
it will be returned unaltered.

Returns:
Generator: The initialized generator object.
""" # NOQA, list of types need to be in one line for sphinx
if runtime.is_hip:
> raise RuntimeError('Generator API not supported in HIP,'
' please use the legacy one.')
E RuntimeError: Generator API not supported in HIP, please use the legacy one.

cupy/random/__init__.py:36: RuntimeError
------------------------------Captured stdout call------------------------------
{'shape_dtype': <class 'numpy.float16'>, 'scale_dtype': <class 'numpy.float16'>}

self = <<cupy_tests.random_tests.test_distributions.TestDistributionsGamma_param_19_{dtype=float16, scale_shape=(), shape=(3,...a_generator> parameter: {'dtype': <class 'numpy.float16'>, 'scale_shape': (), 'shape': (3, 2), 'shape_shape': (3, 2)}>
shape_dtype = <class 'numpy.float16'>, scale_dtype = <class 'numpy.float16'>

@cupy.testing.for_dtypes_combination(
_float_dtypes, names=['shape_dtype', 'scale_dtype'])
def test_gamma_generator(self, shape_dtype, scale_dtype):
> self.check_distribution(cupy.random.default_rng().gamma,
shape_dtype, scale_dtype)

tests/cupy_tests/random_tests/test_distributions.py:195:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

seed = None

def default_rng(seed=None): # NOQA avoid redefinition of seed
"""Construct a new Generator with the default BitGenerator (XORWOW).

Args:
seed (None, int, array_like[ints], numpy.random.SeedSequence, cupy.random.BitGenerator, cupy.random.Generator, optional):
A seed to initialize the :class:`cupy.random.BitGenerator`. If an
``int`` or ``array_like[ints]`` or None is passed, then it will be
passed to :class:`numpy.random.SeedSequence` to detive the initial
:class:`BitGenerator` state. One may also pass in a `SeedSequence
instance. Adiditionally, when passed :class:`BitGenerator`, it will
be wrapped by :class:`Generator`. If passed a :class:`Generator`,
it will be returned unaltered.

Returns:
Generator: The initialized generator object.
""" # NOQA, list of types need to be in one line for sphinx
if runtime.is_hip:
> raise RuntimeError('Generator API not supported in HIP,'
' please use the legacy one.')
E RuntimeError: Generator API not supported in HIP, please use the legacy one.

cupy/random/__init__.py:36: RuntimeError
------------------------------Captured stdout call------------------------------
{'shape_dtype': <class 'numpy.float16'>, 'scale_dtype': <class 'numpy.float16'>}

self = <<cupy_tests.random_tests.test_distributions.TestDistributionsGamma_param_20_{dtype=float16, scale_shape=(3, 2), shape...enerator> parameter: {'dtype': <class 'numpy.float16'>, 'scale_shape': (3, 2), 'shape': (4, 3, 2), 'shape_shape': ()}>
shape_dtype = <class 'numpy.float16'>, scale_dtype = <class 'numpy.float16'>

@cupy.testing.for_dtypes_combination(
_float_dtypes, names=['shape_dtype', 'scale_dtype'])
def test_gamma_generator(self, shape_dtype, scale_dtype):
> self.check_distribution(cupy.random.default_rng().gamma,
shape_dtype, scale_dtype)

tests/cupy_tests/random_tests/test_distributions.py:195:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

seed = None

def default_rng(seed=None): # NOQA avoid redefinition of seed
"""Construct a new Generator with the default BitGenerator (XORWOW).

Args:
seed (None, int, array_like[ints], numpy.random.SeedSequence, cupy.random.BitGenerator, cupy.random.Generator, optional):
A seed to initialize the :class:`cupy.random.BitGenerator`. If an
``int`` or ``array_like[ints]`` or None is passed, then it will be
passed to :class:`numpy.random.SeedSequence` to detive the initial
:class:`BitGenerator` state. One may also pass in a `SeedSequence
instance. Adiditionally, when passed :class:`BitGenerator`, it will
be wrapped by :class:`Generator`. If passed a :class:`Generator`,
it will be returned unaltered.

Returns:
Generator: The initialized generator object.
""" # NOQA, list of types need to be in one line for sphinx
if runtime.is_hip:
> raise RuntimeError('Generator API not supported in HIP,'
' please use the legacy one.')
E RuntimeError: Generator API not supported in HIP, please use the legacy one.

cupy/random/__init__.py:36: RuntimeError
------------------------------Captured stdout call------------------------------
{'shape_dtype': <class 'numpy.float16'>, 'scale_dtype': <class 'numpy.float16'>}

self = <<cupy_tests.random_tests.test_distributions.TestDistributionsGamma_param_21_{dtype=float16, scale_shape=(3, 2), shape...ator> parameter: {'dtype': <class 'numpy.float16'>, 'scale_shape': (3, 2), 'shape': (4, 3, 2), 'shape_shape': (3, 2)}>
shape_dtype = <class 'numpy.float16'>, scale_dtype = <class 'numpy.float16'>

@cupy.testing.for_dtypes_combination(
_float_dtypes, names=['shape_dtype', 'scale_dtype'])
def test_gamma_generator(self, shape_dtype, scale_dtype):
> self.check_distribution(cupy.random.default_rng().gamma,
shape_dtype, scale_dtype)

tests/cupy_tests/random_tests/test_distributions.py:195:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

seed = None

def default_rng(seed=None): # NOQA avoid redefinition of seed
"""Construct a new Generator with the default BitGenerator (XORWOW).

Args:
seed (None, int, array_like[ints], numpy.random.SeedSequence, cupy.random.BitGenerator, cupy.random.Generator, optional):
A seed to initialize the :class:`cupy.random.BitGenerator`. If an
``int`` or ``array_like[ints]`` or None is passed, then it will be
passed to :class:`numpy.random.SeedSequence` to detive the initial
:class:`BitGenerator` state. One may also pass in a `SeedSequence
instance. Adiditionally, when passed :class:`BitGenerator`, it will
be wrapped by :class:`Generator`. If passed a :class:`Generator`,
it will be returned unaltered.

Returns:
Generator: The initialized generator object.
""" # NOQA, list of types need to be in one line for sphinx
if runtime.is_hip:
> raise RuntimeError('Generator API not supported in HIP,'
' please use the legacy one.')
E RuntimeError: Generator API not supported in HIP, please use the legacy one.

cupy/random/__init__.py:36: RuntimeError
------------------------------Captured stdout call------------------------------
{'shape_dtype': <class 'numpy.float16'>, 'scale_dtype': <class 'numpy.float16'>}

self = <<cupy_tests.random_tests.test_distributions.TestDistributionsGamma_param_22_{dtype=float16, scale_shape=(3, 2), shape...a_generator> parameter: {'dtype': <class 'numpy.float16'>, 'scale_shape': (3, 2), 'shape': (3, 2), 'shape_shape': ()}>
shape_dtype = <class 'numpy.float16'>, scale_dtype = <class 'numpy.float16'>

@cupy.testing.for_dtypes_combination(
_float_dtypes, names=['shape_dtype', 'scale_dtype'])
def test_gamma_generator(self, shape_dtype, scale_dtype):
> self.check_distribution(cupy.random.default_rng().gamma,
shape_dtype, scale_dtype)

tests/cupy_tests/random_tests/test_distributions.py:195:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

seed = None

def default_rng(seed=None): # NOQA avoid redefinition of seed
"""Construct a new Generator with the default BitGenerator (XORWOW).

Args:
seed (None, int, array_like[ints], numpy.random.SeedSequence, cupy.random.BitGenerator, cupy.random.Generator, optional):
A seed to initialize the :class:`cupy.random.BitGenerator`. If an
``int`` or ``array_like[ints]`` or None is passed, then it will be
passed to :class:`numpy.random.SeedSequence` to detive the initial
:class:`BitGenerator` state. One may also pass in a `SeedSequence
instance. Adiditionally, when passed :class:`BitGenerator`, it will
be wrapped by :class:`Generator`. If passed a :class:`Generator`,
it will be returned unaltered.

Returns:
Generator: The initialized generator object.
""" # NOQA, list of types need to be in one line for sphinx
if runtime.is_hip:
> raise RuntimeError('Generator API not supported in HIP,'
' please use the legacy one.')
E RuntimeError: Generator API not supported in HIP, please use the legacy one.

cupy/random/__init__.py:36: RuntimeError
------------------------------Captured stdout call------------------------------
{'shape_dtype': <class 'numpy.float16'>, 'scale_dtype': <class 'numpy.float16'>}

self = <<cupy_tests.random_tests.test_distributions.TestDistributionsGamma_param_23_{dtype=float16, scale_shape=(3, 2), shape...nerator> parameter: {'dtype': <class 'numpy.float16'>, 'scale_shape': (3, 2), 'shape': (3, 2), 'shape_shape': (3, 2)}>
shape_dtype = <class 'numpy.float16'>, scale_dtype = <class 'numpy.float16'>

@cupy.testing.for_dtypes_combination(
_float_dtypes, names=['shape_dtype', 'scale_dtype'])
def test_gamma_generator(self, shape_dtype, scale_dtype):
> self.check_distribution(cupy.random.default_rng().gamma,
shape_dtype, scale_dtype)

tests/cupy_tests/random_tests/test_distributions.py:195:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

seed = None

def default_rng(seed=None): # NOQA avoid redefinition of seed
"""Construct a new Generator with the default BitGenerator (XORWOW).

Args:
seed (None, int, array_like[ints], numpy.random.SeedSequence, cupy.random.BitGenerator, cupy.random.Generator, optional):
A seed to initialize the :class:`cupy.random.BitGenerator`. If an
``int`` or ``array_like[ints]`` or None is passed, then it will be
passed to :class:`numpy.random.SeedSequence` to detive the initial
:class:`BitGenerator` state. One may also pass in a `SeedSequence
instance. Adiditionally, when passed :class:`BitGenerator`, it will
be wrapped by :class:`Generator`. If passed a :class:`Generator`,
it will be returned unaltered.

Returns:
Generator: The initialized generator object.
""" # NOQA, list of types need to be in one line for sphinx
if runtime.is_hip:
> raise RuntimeError('Generator API not supported in HIP,'
' please use the legacy one.')
E RuntimeError: Generator API not supported in HIP, please use the legacy one.

cupy/random/__init__.py:36: RuntimeError
------------------------------Captured stdout call------------------------------
{'shape_dtype': <class 'numpy.float16'>, 'scale_dtype': <class 'numpy.float16'>}

self = <<cupy_tests.random_tests.test_distributions.TestDistributionsStandardGamma_param_0_{shape=(4, 3, 2), shape_shape=()} testMethod=test_standard_gamma_generator> parameter: {'shape': (4, 3, 2), 'shape_shape': ()}>
shape_dtype = <class 'numpy.float64'>, dtype = <class 'numpy.float64'>

@cupy.testing.for_float_dtypes('dtype', no_float16=True)
@cupy.testing.for_float_dtypes('shape_dtype')
def test_standard_gamma_generator(self, shape_dtype, dtype):
shape = numpy.ones(self.shape_shape, dtype=shape_dtype)
> self.check_generator_distribution('standard_gamma',
{'shape': shape},
dtype)

tests/cupy_tests/random_tests/test_distributions.py:639:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
tests/cupy_tests/random_tests/test_distributions.py:31: in check_generator_distribution
cp_gen = cupy.random.default_rng()
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

seed = None

def default_rng(seed=None): # NOQA avoid redefinition of seed
"""Construct a new Generator with the default BitGenerator (XORWOW).

Args:
seed (None, int, array_like[ints], numpy.random.SeedSequence, cupy.random.BitGenerator, cupy.random.Generator, optional):
A seed to initialize the :class:`cupy.random.BitGenerator`. If an
``int`` or ``array_like[ints]`` or None is passed, then it will be
passed to :class:`numpy.random.SeedSequence` to detive the initial
:class:`BitGenerator` state. One may also pass in a `SeedSequence
instance. Adiditionally, when passed :class:`BitGenerator`, it will
be wrapped by :class:`Generator`. If passed a :class:`Generator`,
it will be returned unaltered.

Returns:
Generator: The initialized generator object.
""" # NOQA, list of types need to be in one line for sphinx
if runtime.is_hip:
> raise RuntimeError('Generator API not supported in HIP,'
' please use the legacy one.')
E RuntimeError: Generator API not supported in HIP, please use the legacy one.

cupy/random/__init__.py:36: RuntimeError
------------------------------Captured stdout call------------------------------
shape_dtype is <class 'numpy.float64'> dtype is <class 'numpy.float64'>

self = <<cupy_tests.random_tests.test_distributions.TestDistributionsStandardGamma_param_1_{shape=(4, 3, 2), shape_shape=(3, 2)} testMethod=test_standard_gamma_generator> parameter: {'shape': (4, 3, 2), 'shape_shape': (3, 2)}>
shape_dtype = <class 'numpy.float64'>, dtype = <class 'numpy.float64'>

@cupy.testing.for_float_dtypes('dtype', no_float16=True)
@cupy.testing.for_float_dtypes('shape_dtype')
def test_standard_gamma_generator(self, shape_dtype, dtype):
shape = numpy.ones(self.shape_shape, dtype=shape_dtype)
> self.check_generator_distribution('standard_gamma',
{'shape': shape},
dtype)

tests/cupy_tests/random_tests/test_distributions.py:639:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
tests/cupy_tests/random_tests/test_distributions.py:31: in check_generator_distribution
cp_gen = cupy.random.default_rng()
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

seed = None

def default_rng(seed=None): # NOQA avoid redefinition of seed
"""Construct a new Generator with the default BitGenerator (XORWOW).

Args:
seed (None, int, array_like[ints], numpy.random.SeedSequence, cupy.random.BitGenerator, cupy.random.Generator, optional):
A seed to initialize the :class:`cupy.random.BitGenerator`. If an
``int`` or ``array_like[ints]`` or None is passed, then it will be
passed to :class:`numpy.random.SeedSequence` to detive the initial
:class:`BitGenerator` state. One may also pass in a `SeedSequence
instance. Adiditionally, when passed :class:`BitGenerator`, it will
be wrapped by :class:`Generator`. If passed a :class:`Generator`,
it will be returned unaltered.

Returns:
Generator: The initialized generator object.
""" # NOQA, list of types need to be in one line for sphinx
if runtime.is_hip:
> raise RuntimeError('Generator API not supported in HIP,'
' please use the legacy one.')
E RuntimeError: Generator API not supported in HIP, please use the legacy one.

cupy/random/__init__.py:36: RuntimeError
------------------------------Captured stdout call------------------------------
shape_dtype is <class 'numpy.float64'> dtype is <class 'numpy.float64'>

self = <<cupy_tests.random_tests.test_distributions.TestDistributionsStandardGamma_param_2_{shape=(3, 2), shape_shape=()} testMethod=test_standard_gamma_generator> parameter: {'shape': (3, 2), 'shape_shape': ()}>
shape_dtype = <class 'numpy.float64'>, dtype = <class 'numpy.float64'>

@cupy.testing.for_float_dtypes('dtype', no_float16=True)
@cupy.testing.for_float_dtypes('shape_dtype')
def test_standard_gamma_generator(self, shape_dtype, dtype):
shape = numpy.ones(self.shape_shape, dtype=shape_dtype)
> self.check_generator_distribution('standard_gamma',
{'shape': shape},
dtype)

tests/cupy_tests/random_tests/test_distributions.py:639:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
tests/cupy_tests/random_tests/test_distributions.py:31: in check_generator_distribution
cp_gen = cupy.random.default_rng()
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

seed = None

def default_rng(seed=None): # NOQA avoid redefinition of seed
"""Construct a new Generator with the default BitGenerator (XORWOW).

Args:
seed (None, int, array_like[ints], numpy.random.SeedSequence, cupy.random.BitGenerator, cupy.random.Generator, optional):
A seed to initialize the :class:`cupy.random.BitGenerator`. If an
``int`` or ``array_like[ints]`` or None is passed, then it will be
passed to :class:`numpy.random.SeedSequence` to detive the initial
:class:`BitGenerator` state. One may also pass in a `SeedSequence
instance. Adiditionally, when passed :class:`BitGenerator`, it will
be wrapped by :class:`Generator`. If passed a :class:`Generator`,
it will be returned unaltered.

Returns:
Generator: The initialized generator object.
""" # NOQA, list of types need to be in one line for sphinx
if runtime.is_hip:
> raise RuntimeError('Generator API not supported in HIP,'
' please use the legacy one.')
E RuntimeError: Generator API not supported in HIP, please use the legacy one.

cupy/random/__init__.py:36: RuntimeError
------------------------------Captured stdout call------------------------------
shape_dtype is <class 'numpy.float64'> dtype is <class 'numpy.float64'>

self = <<cupy_tests.random_tests.test_distributions.TestDistributionsStandardGamma_param_3_{shape=(3, 2), shape_shape=(3, 2)} testMethod=test_standard_gamma_generator> parameter: {'shape': (3, 2), 'shape_shape': (3, 2)}>
shape_dtype = <class 'numpy.float64'>, dtype = <class 'numpy.float64'>

@cupy.testing.for_float_dtypes('dtype', no_float16=True)
@cupy.testing.for_float_dtypes('shape_dtype')
def test_standard_gamma_generator(self, shape_dtype, dtype):
shape = numpy.ones(self.shape_shape, dtype=shape_dtype)
> self.check_generator_distribution('standard_gamma',
{'shape': shape},
dtype)

tests/cupy_tests/random_tests/test_distributions.py:639:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
tests/cupy_tests/random_tests/test_distributions.py:31: in check_generator_distribution
cp_gen = cupy.random.default_rng()
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

seed = None

def default_rng(seed=None): # NOQA avoid redefinition of seed
"""Construct a new Generator with the default BitGenerator (XORWOW).

Args:
seed (None, int, array_like[ints], numpy.random.SeedSequence, cupy.random.BitGenerator, cupy.random.Generator, optional):
A seed to initialize the :class:`cupy.random.BitGenerator`. If an
``int`` or ``array_like[ints]`` or None is passed, then it will be
passed to :class:`numpy.random.SeedSequence` to detive the initial
:class:`BitGenerator` state. One may also pass in a `SeedSequence
instance. Adiditionally, when passed :class:`BitGenerator`, it will
be wrapped by :class:`Generator`. If passed a :class:`Generator`,
it will be returned unaltered.

Returns:
Generator: The initialized generator object.
""" # NOQA, list of types need to be in one line for sphinx
if runtime.is_hip:
> raise RuntimeError('Generator API not supported in HIP,'
' please use the legacy one.')
E RuntimeError: Generator API not supported in HIP, please use the legacy one.

cupy/random/__init__.py:36: RuntimeError
------------------------------Captured stdout call------------------------------
shape_dtype is <class 'numpy.float64'> dtype is <class 'numpy.float64'>

self = <cupyx_tests.test_scatter.TestScatter testMethod=test_scatter_add>
dtype = <class 'numpy.float16'>

@testing.for_dtypes('iILQefd')
def test_scatter_add(self, dtype):
a = cupy.zeros((3,), dtype=dtype)
i = cupy.array([1, 1], numpy.int32)
v = cupy.array([2., 1.], dtype=dtype)
cupyx.scatter_add(a, i, v)
> testing.assert_array_equal(a, cupy.array([0, 3, 0], dtype=dtype))

tests/cupyx_tests/test_scatter.py:19:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

x = array([0.e+00, 2.e-07, 0.e+00], dtype=float16)
y = array([0., 3., 0.], dtype=float16), err_msg = '', verbose = True
strides_check = False

def assert_array_equal(x, y, err_msg='', verbose=True, strides_check=False):
"""Raises an AssertionError if two array_like objects are not equal.

Args:
x(numpy.ndarray or cupy.ndarray): The actual object to check.
y(numpy.ndarray or cupy.ndarray): The desired, expected object.
strides_check(bool): If ``True``, consistency of strides is also
checked.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting values
are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_array_equal`
"""
> numpy.testing.assert_array_equal(
cupy.asnumpy(x), cupy.asnumpy(y), err_msg=err_msg,
verbose=verbose)
E AssertionError:
E Arrays are not equal
E
E Mismatched elements: 1 / 3 (33.3%)
E Max absolute difference: 3.
E Max relative difference: 1.
E x: array([0.e+00, 2.e-07, 0.e+00], dtype=float16)
E y: array([0., 3., 0.], dtype=float16)

cupy/testing/_array.py:91: AssertionError
------------------------------Captured stdout call------------------------------
dtype is e

self = <<cupyx_tests.scipy_tests.linalg_tests.test_decomp_lu.TestLUSolve_param_0_{shapes=((4, 4), (4,)), trans=0} testMethod=test_lu_solve> parameter: {'shapes': ((4, 4), (4,)), 'trans': 0}>
xp = <module 'cupy' from '/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.qkYzcmVKAz/cupy/cupy/__init__.py'>
scp = <module 'cupyx.scipy' from '/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.qkYzcmVKAz/cupy/cupyx/scipy/__init__.py'>
dtype = <class 'numpy.float32'>

@testing.for_dtypes('fdFD')
@testing.numpy_cupy_allclose(atol=1e-5, scipy_name='scp')
def test_lu_solve(self, xp, scp, dtype):
a_shape, b_shape = self.shapes
A = testing.shaped_random(a_shape, xp, dtype=dtype)
b = testing.shaped_random(b_shape, xp, dtype=dtype)
lu = scp.linalg.lu_factor(A)
> return scp.linalg.lu_solve(lu, b, trans=self.trans)

tests/cupyx_tests/scipy_tests/linalg_tests/test_decomp_lu.py:133:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

lu_and_piv = (array([[ 9.636627 , 3.8344152 , 7.91725 , 5.288949 ],
[ 0.58946407, 6.995716 , -3.956574 , -2.246352...,
[ 0.43962973, 0.6823059 , 0.83048815, 4.776696 ]],
dtype=float32), array([2, 3, 2, 3], dtype=int32))
b = array([ 0.5098284 , 0.25080842, -0.34704718, 0.5484196 ], dtype=float32)
trans = 0, overwrite_b = False, check_finite = True

def lu_solve(lu_and_piv, b, trans=0, overwrite_b=False, check_finite=True):
"""Solve an equation system, ``a * x = b``, given the LU factorization of ``a``

Args:
lu_and_piv (tuple): LU factorization of matrix ``a`` (``(M, M)``)
together with pivot indices.
b (cupy.ndarray): The matrix with dimension ``(M,)`` or
``(M, N)``.
trans ({0, 1, 2}): Type of system to solve:

======== =========
trans system
======== =========
0 a x = b
1 a^T x = b
2 a^H x = b
======== =========
overwrite_b (bool): Allow overwriting data in b (may enhance
performance)
check_finite (bool): Whether to check that the input matrices contain
only finite numbers. Disabling may give a performance gain, but may
result in problems (crashes, non-termination) if the inputs do
contain infinities or NaNs.

Returns:
cupy.ndarray:
The matrix with dimension ``(M,)`` or ``(M, N)``.

.. seealso:: :func:`scipy.linalg.lu_solve`
"""

(lu, ipiv) = lu_and_piv

_util._assert_cupy_array(lu)
_util._assert_rank2(lu)
_util._assert_nd_squareness(lu)

m = lu.shape[0]
if m != b.shape[0]:
raise ValueError('incompatible dimensions.')

dtype = lu.dtype
if dtype.char == 'f':
getrs = cusolver.sgetrs
elif dtype.char == 'd':
getrs = cusolver.dgetrs
elif dtype.char == 'F':
getrs = cusolver.cgetrs
elif dtype.char == 'D':
getrs = cusolver.zgetrs
else:
msg = 'Only float32, float64, complex64 and complex128 are supported.'
raise NotImplementedError(msg)

if trans == 0:
trans = cublas.CUBLAS_OP_N
elif trans == 1:
trans = cublas.CUBLAS_OP_T
elif trans == 2:
trans = cublas.CUBLAS_OP_C
else:
raise ValueError('unknown trans')

lu = lu.astype(dtype, order='F', copy=False)
ipiv = ipiv.astype(ipiv.dtype, order='F', copy=True)
# cuSolver uses 1-origin while SciPy uses 0-origin
ipiv += 1
b = b.astype(dtype, order='F', copy=(not overwrite_b))

if check_finite:
if lu.dtype.kind == 'f' and not cupy.isfinite(lu).all():
raise ValueError(
'array must not contain infs or NaNs.\n'
'Note that when a singular matrix is given, unlike '
'scipy.linalg.lu_factor, cupyx.scipy.linalg.lu_factor '
'returns an array containing NaN.')
if b.dtype.kind == 'f' and not cupy.isfinite(b).all():
raise ValueError(
'array must not contain infs or NaNs')

n = 1 if b.ndim == 1 else b.shape[1]
cusolver_handle = device.get_cusolver_handle()
dev_info = cupy.empty(1, dtype=numpy.int32)

# solve for the inverse
getrs(cusolver_handle,
trans,
m, n, lu.data.ptr, m, ipiv.data.ptr, b.data.ptr,
m, dev_info.data.ptr)

if dev_info[0] < 0:
> raise ValueError('illegal value in %d-th argument of '
'internal getrs (lu_solve)' % -dev_info[0])
E AssertionError: Only cupy raises error
E
E Traceback (most recent call last):
E File "/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.qkYzcmVKAz/cupy/cupy/testing/_helper.py", line 47, in _call_func
E result = impl(self, *args, **kw)
E File "/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.qkYzcmVKAz/cupy/tests/cupyx_tests/scipy_tests/linalg_tests/test_decomp_lu.py", line 133, in test_lu_solve
E return scp.linalg.lu_solve(lu, b, trans=self.trans)
E File "/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.qkYzcmVKAz/cupy/cupyx/scipy/linalg/decomp_lu.py", line 344, in lu_solve
E raise ValueError('illegal value in %d-th argument of '
E ValueError: illegal value in 1409886463-th argument of internal getrs (lu_solve)

cupyx/scipy/linalg/decomp_lu.py:344: AssertionError
------------------------------Captured stdout call------------------------------
dtype is f

self = <<cupyx_tests.scipy_tests.linalg_tests.test_decomp_lu.TestLUSolve_param_3_{shapes=((5, 5), (5, 2)), trans=0} testMethod=test_lu_solve> parameter: {'shapes': ((5, 5), (5, 2)), 'trans': 0}>
xp = <module 'cupy' from '/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.qkYzcmVKAz/cupy/cupy/__init__.py'>
scp = <module 'cupyx.scipy' from '/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.qkYzcmVKAz/cupy/cupyx/scipy/__init__.py'>
dtype = <class 'numpy.complex128'>

@testing.for_dtypes('fdFD')
@testing.numpy_cupy_allclose(atol=1e-5, scipy_name='scp')
def test_lu_solve(self, xp, scp, dtype):
a_shape, b_shape = self.shapes
A = testing.shaped_random(a_shape, xp, dtype=dtype)
b = testing.shaped_random(b_shape, xp, dtype=dtype)
lu = scp.linalg.lu_factor(A)
> return scp.linalg.lu_solve(lu, b, trans=self.trans)

tests/cupyx_tests/scipy_tests/linalg_tests/test_decomp_lu.py:133:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

lu_and_piv = (array([[ 9.78618342 +6.7063787j , 7.99158564 +2.10382561j,
4.61479362 +1.28926298j, 7.80529176 +3.15428351...09693 +0.11253535j, -0.19530724 +0.3829403j ,
1.48165651 +3.00519867j]]), array([4, 1, 4, 3, 4], dtype=int32))
b = array([[ 2.62387605-0.26982085j, 2.2387386 +2.17849744j],
[-1.24752213-1.21928963j, 1.06884568-2.83274516j],
...
[-0.94068427+3.72322175j, -5.04078357+2.5571273j ],
[-3.22951911-0.30141784j, -2.28920225-3.23327497j]])
trans = 0, overwrite_b = False, check_finite = True

def lu_solve(lu_and_piv, b, trans=0, overwrite_b=False, check_finite=True):
"""Solve an equation system, ``a * x = b``, given the LU factorization of ``a``

Args:
lu_and_piv (tuple): LU factorization of matrix ``a`` (``(M, M)``)
together with pivot indices.
b (cupy.ndarray): The matrix with dimension ``(M,)`` or
``(M, N)``.
trans ({0, 1, 2}): Type of system to solve:

======== =========
trans system
======== =========
0 a x = b
1 a^T x = b
2 a^H x = b
======== =========
overwrite_b (bool): Allow overwriting data in b (may enhance
performance)
check_finite (bool): Whether to check that the input matrices contain
only finite numbers. Disabling may give a performance gain, but may
result in problems (crashes, non-termination) if the inputs do
contain infinities or NaNs.

Returns:
cupy.ndarray:
The matrix with dimension ``(M,)`` or ``(M, N)``.

.. seealso:: :func:`scipy.linalg.lu_solve`
"""

(lu, ipiv) = lu_and_piv

_util._assert_cupy_array(lu)
_util._assert_rank2(lu)
_util._assert_nd_squareness(lu)

m = lu.shape[0]
if m != b.shape[0]:
raise ValueError('incompatible dimensions.')

dtype = lu.dtype
if dtype.char == 'f':
getrs = cusolver.sgetrs
elif dtype.char == 'd':
getrs = cusolver.dgetrs
elif dtype.char == 'F':
getrs = cusolver.cgetrs
elif dtype.char == 'D':
getrs = cusolver.zgetrs
else:
msg = 'Only float32, float64, complex64 and complex128 are supported.'
raise NotImplementedError(msg)

if trans == 0:
trans = cublas.CUBLAS_OP_N
elif trans == 1:
trans = cublas.CUBLAS_OP_T
elif trans == 2:
trans = cublas.CUBLAS_OP_C
else:
raise ValueError('unknown trans')

lu = lu.astype(dtype, order='F', copy=False)
ipiv = ipiv.astype(ipiv.dtype, order='F', copy=True)
# cuSolver uses 1-origin while SciPy uses 0-origin
ipiv += 1
b = b.astype(dtype, order='F', copy=(not overwrite_b))

if check_finite:
if lu.dtype.kind == 'f' and not cupy.isfinite(lu).all():
raise ValueError(
'array must not contain infs or NaNs.\n'
'Note that when a singular matrix is given, unlike '
'scipy.linalg.lu_factor, cupyx.scipy.linalg.lu_factor '
'returns an array containing NaN.')
if b.dtype.kind == 'f' and not cupy.isfinite(b).all():
raise ValueError(
'array must not contain infs or NaNs')

n = 1 if b.ndim == 1 else b.shape[1]
cusolver_handle = device.get_cusolver_handle()
dev_info = cupy.empty(1, dtype=numpy.int32)

# solve for the inverse
getrs(cusolver_handle,
trans,
m, n, lu.data.ptr, m, ipiv.data.ptr, b.data.ptr,
m, dev_info.data.ptr)

if dev_info[0] < 0:
> raise ValueError('illegal value in %d-th argument of '
'internal getrs (lu_solve)' % -dev_info[0])
E AssertionError: Only cupy raises error
E
E Traceback (most recent call last):
E File "/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.qkYzcmVKAz/cupy/cupy/testing/_helper.py", line 47, in _call_func
E result = impl(self, *args, **kw)
E File "/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.qkYzcmVKAz/cupy/tests/cupyx_tests/scipy_tests/linalg_tests/test_decomp_lu.py", line 133, in test_lu_solve
E return scp.linalg.lu_solve(lu, b, trans=self.trans)
E File "/home/kmaeh/Development/cupy-rocm-ci-report/tools/tmp.qkYzcmVKAz/cupy/cupyx/scipy/linalg/decomp_lu.py", line 344, in lu_solve
E raise ValueError('illegal value in %d-th argument of '
E ValueError: illegal value in 1573970959-th argument of internal getrs (lu_solve)

cupyx/scipy/linalg/decomp_lu.py:344: AssertionError
------------------------------Captured stdout call------------------------------
dtype is D

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_filters.TestGenericFilter object at 0x7f24ea36f400> parameter: {'filter'...ss 'numpy.uint8'>, 'ksize': 3, 'mode': 'mirror', 'shape': (4, 5), 'function': <function rms_pyfunc at 0x7f25f5f744c0>}>
args = (), kw = {}
cupy_result = (array([[21, 31, 40, 31, 33],
[27, 29, 28, 20, 27],
[14, 25, 35, 34, 32],
[27, 26, 33, 25, 31]], dtype=uint8),)
cupy_error = None
numpy_result = (array([[28, 38, 48, 42, 45],
[32, 36, 44, 37, 44],
[18, 31, 45, 48, 55],
[22, 29, 41, 43, 54]], dtype=uint8),)
numpy_error = None
cupy_numpy_result_ndarrays = [(array([[21, 31, 40, 31, 33],
[27, 29, 28, 20, 27],
[14, 25, 35, 34, 32],
[27, 26, 33, 25, 31]],...38, 48, 42, 45],
[32, 36, 44, 37, 44],
[18, 31, 45, 48, 55],
[22, 29, 41, 43, 54]], dtype=uint8))]
cupy_r = array([[21, 31, 40, 31, 33],
[27, 29, 28, 20, 27],
[14, 25, 35, 34, 32],
[27, 26, 33, 25, 31]], dtype=uint8)
numpy_r = array([[28, 38, 48, 42, 45],
[32, 36, 44, 37, 44],
[18, 31, 45, 48, 55],
[22, 29, 41, 43, 54]], dtype=uint8)
skip = False

@_wraps_partial_xp(impl, name, sp_name, scipy_name)
def test_func(self, *args, **kw):
# Run cupy and numpy
(
cupy_result, cupy_error,
numpy_result, numpy_error) = (
_call_func_numpy_cupy(
self, impl, args, kw, name, sp_name, scipy_name))
assert cupy_result is not None or cupy_error is not None
assert numpy_result is not None or numpy_error is not None

# Check errors raised
if cupy_error or numpy_error:
_check_cupy_numpy_error(cupy_error,
numpy_error,
accept_error=accept_error)
return

# Check returned arrays

if not isinstance(cupy_result, (tuple, list)):
cupy_result = cupy_result,
if not isinstance(numpy_result, (tuple, list)):
numpy_result = numpy_result,

assert len(cupy_result) == len(numpy_result)

# Check types
cupy_numpy_result_ndarrays = [
_convert_output_to_ndarray(
cupy_r, numpy_r, sp_name, check_sparse_format)
for cupy_r, numpy_r in zip(cupy_result, numpy_result)]

# Check dtypes
if type_check:
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
if cupy_r.dtype != numpy_r.dtype:
raise AssertionError(
'''ndarrays of different dtypes are returned.
cupy: {}
numpy: {}'''.format(cupy_r.dtype, numpy_r.dtype))

# Check contiguities
if contiguous_check:
for cupy_r, numpy_r in zip(cupy_result, numpy_result):
if isinstance(numpy_r, numpy.ndarray):
if (numpy_r.flags.c_contiguous
and not cupy_r.flags.c_contiguous):
raise AssertionError(
'The state of c_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.c_contiguous,
numpy_r.flags.c_contiguous))
if (numpy_r.flags.f_contiguous
and not cupy_r.flags.f_contiguous):
raise AssertionError(
'The state of f_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.f_contiguous,
numpy_r.flags.f_contiguous))

# Check shapes
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
assert cupy_r.shape == numpy_r.shape

# Check item values
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
# Behavior of assigning a negative value to an unsigned integer
# variable is undefined.
# nVidia GPUs and Intel CPUs behave differently.
# To avoid this difference, we need to ignore dimensions whose
# values are negative.

skip = False
if (_contains_signed_and_unsigned(kw)
and cupy_r.dtype in _unsigned_dtypes):
mask = _make_positive_mask(
self, impl, args, kw, name, sp_name, scipy_name)
if cupy_r.shape == ():
skip = (mask == 0).all()
else:
cupy_r = cupy_r[mask].get()
numpy_r = numpy_r[mask]

if not skip:
> check_func(cupy_r, numpy_r)

cupy/testing/_helper.py:343:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[21, 31, 40, 31, 33],
[27, 29, 28, 20, 27],
[14, 25, 35, 34, 32],
[27, 26, 33, 25, 31]], dtype=uint8)
desired = array([[28, 38, 48, 42, 45],
[32, 36, 44, 37, 44],
[18, 31, 45, 48, 55],
[22, 29, 41, 43, 54]], dtype=uint8)
rtol = 1e-05, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-05, atol=1e-05
E
E Mismatched elements: 20 / 20 (100%)
E Max absolute difference: 253
E Max relative difference: 14.
E x: array([[21, 31, 40, 31, 33],
E [27, 29, 28, 20, 27],
E [14, 25, 35, 34, 32],
E [27, 26, 33, 25, 31]], dtype=uint8)
E y: array([[28, 38, 48, 42, 45],
E [32, 36, 44, 37, 44],
E [18, 31, 45, 48, 55],
E [22, 29, 41, 43, 54]], dtype=uint8)

cupy/testing/_array.py:24: AssertionError

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_filters.TestGenericFilter object at 0x7f24ea37f550> parameter: {'filter'...ss 'numpy.uint8'>, 'ksize': 4, 'mode': 'mirror', 'shape': (4, 5), 'function': <function rms_pyfunc at 0x7f25f5f744c0>}>
args = (), kw = {}
cupy_result = (array([[28, 24, 32, 32, 39],
[ 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0]], dtype=uint8),)
cupy_error = None
numpy_result = (array([[34, 34, 44, 37, 47],
[34, 34, 44, 37, 47],
[29, 29, 39, 37, 46],
[27, 27, 41, 38, 52]], dtype=uint8),)
numpy_error = None
cupy_numpy_result_ndarrays = [(array([[28, 24, 32, 32, 39],
[ 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0]],...34, 44, 37, 47],
[34, 34, 44, 37, 47],
[29, 29, 39, 37, 46],
[27, 27, 41, 38, 52]], dtype=uint8))]
cupy_r = array([[28, 24, 32, 32, 39],
[ 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0]], dtype=uint8)
numpy_r = array([[34, 34, 44, 37, 47],
[34, 34, 44, 37, 47],
[29, 29, 39, 37, 46],
[27, 27, 41, 38, 52]], dtype=uint8)
skip = False

@_wraps_partial_xp(impl, name, sp_name, scipy_name)
def test_func(self, *args, **kw):
# Run cupy and numpy
(
cupy_result, cupy_error,
numpy_result, numpy_error) = (
_call_func_numpy_cupy(
self, impl, args, kw, name, sp_name, scipy_name))
assert cupy_result is not None or cupy_error is not None
assert numpy_result is not None or numpy_error is not None

# Check errors raised
if cupy_error or numpy_error:
_check_cupy_numpy_error(cupy_error,
numpy_error,
accept_error=accept_error)
return

# Check returned arrays

if not isinstance(cupy_result, (tuple, list)):
cupy_result = cupy_result,
if not isinstance(numpy_result, (tuple, list)):
numpy_result = numpy_result,

assert len(cupy_result) == len(numpy_result)

# Check types
cupy_numpy_result_ndarrays = [
_convert_output_to_ndarray(
cupy_r, numpy_r, sp_name, check_sparse_format)
for cupy_r, numpy_r in zip(cupy_result, numpy_result)]

# Check dtypes
if type_check:
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
if cupy_r.dtype != numpy_r.dtype:
raise AssertionError(
'''ndarrays of different dtypes are returned.
cupy: {}
numpy: {}'''.format(cupy_r.dtype, numpy_r.dtype))

# Check contiguities
if contiguous_check:
for cupy_r, numpy_r in zip(cupy_result, numpy_result):
if isinstance(numpy_r, numpy.ndarray):
if (numpy_r.flags.c_contiguous
and not cupy_r.flags.c_contiguous):
raise AssertionError(
'The state of c_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.c_contiguous,
numpy_r.flags.c_contiguous))
if (numpy_r.flags.f_contiguous
and not cupy_r.flags.f_contiguous):
raise AssertionError(
'The state of f_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.f_contiguous,
numpy_r.flags.f_contiguous))

# Check shapes
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
assert cupy_r.shape == numpy_r.shape

# Check item values
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
# Behavior of assigning a negative value to an unsigned integer
# variable is undefined.
# nVidia GPUs and Intel CPUs behave differently.
# To avoid this difference, we need to ignore dimensions whose
# values are negative.

skip = False
if (_contains_signed_and_unsigned(kw)
and cupy_r.dtype in _unsigned_dtypes):
mask = _make_positive_mask(
self, impl, args, kw, name, sp_name, scipy_name)
if cupy_r.shape == ():
skip = (mask == 0).all()
else:
cupy_r = cupy_r[mask].get()
numpy_r = numpy_r[mask]

if not skip:
> check_func(cupy_r, numpy_r)

cupy/testing/_helper.py:343:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[28, 24, 32, 32, 39],
[ 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0]], dtype=uint8)
desired = array([[34, 34, 44, 37, 47],
[34, 34, 44, 37, 47],
[29, 29, 39, 37, 46],
[27, 27, 41, 38, 52]], dtype=uint8)
rtol = 1e-05, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-05, atol=1e-05
E
E Mismatched elements: 20 / 20 (100%)
E Max absolute difference: 251
E Max relative difference: 8.48148148
E x: array([[28, 24, 32, 32, 39],
E [ 0, 0, 0, 0, 0],
E [ 0, 0, 0, 0, 0],
E [ 0, 0, 0, 0, 0]], dtype=uint8)
E y: array([[34, 34, 44, 37, 47],
E [34, 34, 44, 37, 47],
E [29, 29, 39, 37, 46],
E [27, 27, 41, 38, 52]], dtype=uint8)

cupy/testing/_array.py:24: AssertionError

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_filters.TestGenericFilter object at 0x7f24e9fc51f0> parameter: {'filter'... 'numpy.float64'>, 'ksize': 3, 'mode': 'mirror', 'shape': (4, 5), 'function': <function rms_pyfunc at 0x7f25f5f744c0>}>
args = (), kw = {}
cupy_result = (array([[30.36659675, 39.62975648, 53.45565341, 42.0701155 , 42.81412414],
[33.36838531, 37.73390254, 33.011765...2, 44.03386405, 43.67148673, 48.63067102],
[32.28830047, 30.15609296, 36.65741325, 35.73179981, 40.69098504]]),)
cupy_error = None
numpy_result = (array([[32.49418447, 44.26508328, 55.58324819, 50.90632842, 53.13241351],
[36.78467189, 42.32410703, 50.513759...4, 51.93015205, 56.78985728, 63.23111802],
[26.45539443, 35.1080233 , 46.86066347, 49.16227375, 60.05539763]]),)
numpy_error = None
cupy_numpy_result_ndarrays = [(array([[30.36659675, 39.62975648, 53.45565341, 42.0701155 , 42.81412414],
[33.36838531, 37.73390254, 33.01176...4, 51.93015205, 56.78985728, 63.23111802],
[26.45539443, 35.1080233 , 46.86066347, 49.16227375, 60.05539763]]))]
cupy_r = array([[30.36659675, 39.62975648, 53.45565341, 42.0701155 , 42.81412414],
[33.36838531, 37.73390254, 33.0117654...672, 44.03386405, 43.67148673, 48.63067102],
[32.28830047, 30.15609296, 36.65741325, 35.73179981, 40.69098504]])
numpy_r = array([[32.49418447, 44.26508328, 55.58324819, 50.90632842, 53.13241351],
[36.78467189, 42.32410703, 50.5137596...954, 51.93015205, 56.78985728, 63.23111802],
[26.45539443, 35.1080233 , 46.86066347, 49.16227375, 60.05539763]])
skip = False

@_wraps_partial_xp(impl, name, sp_name, scipy_name)
def test_func(self, *args, **kw):
# Run cupy and numpy
(
cupy_result, cupy_error,
numpy_result, numpy_error) = (
_call_func_numpy_cupy(
self, impl, args, kw, name, sp_name, scipy_name))
assert cupy_result is not None or cupy_error is not None
assert numpy_result is not None or numpy_error is not None

# Check errors raised
if cupy_error or numpy_error:
_check_cupy_numpy_error(cupy_error,
numpy_error,
accept_error=accept_error)
return

# Check returned arrays

if not isinstance(cupy_result, (tuple, list)):
cupy_result = cupy_result,
if not isinstance(numpy_result, (tuple, list)):
numpy_result = numpy_result,

assert len(cupy_result) == len(numpy_result)

# Check types
cupy_numpy_result_ndarrays = [
_convert_output_to_ndarray(
cupy_r, numpy_r, sp_name, check_sparse_format)
for cupy_r, numpy_r in zip(cupy_result, numpy_result)]

# Check dtypes
if type_check:
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
if cupy_r.dtype != numpy_r.dtype:
raise AssertionError(
'''ndarrays of different dtypes are returned.
cupy: {}
numpy: {}'''.format(cupy_r.dtype, numpy_r.dtype))

# Check contiguities
if contiguous_check:
for cupy_r, numpy_r in zip(cupy_result, numpy_result):
if isinstance(numpy_r, numpy.ndarray):
if (numpy_r.flags.c_contiguous
and not cupy_r.flags.c_contiguous):
raise AssertionError(
'The state of c_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.c_contiguous,
numpy_r.flags.c_contiguous))
if (numpy_r.flags.f_contiguous
and not cupy_r.flags.f_contiguous):
raise AssertionError(
'The state of f_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.f_contiguous,
numpy_r.flags.f_contiguous))

# Check shapes
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
assert cupy_r.shape == numpy_r.shape

# Check item values
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
# Behavior of assigning a negative value to an unsigned integer
# variable is undefined.
# nVidia GPUs and Intel CPUs behave differently.
# To avoid this difference, we need to ignore dimensions whose
# values are negative.

skip = False
if (_contains_signed_and_unsigned(kw)
and cupy_r.dtype in _unsigned_dtypes):
mask = _make_positive_mask(
self, impl, args, kw, name, sp_name, scipy_name)
if cupy_r.shape == ():
skip = (mask == 0).all()
else:
cupy_r = cupy_r[mask].get()
numpy_r = numpy_r[mask]

if not skip:
> check_func(cupy_r, numpy_r)

cupy/testing/_helper.py:343:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[30.36659675, 39.62975648, 53.45565341, 42.0701155 , 42.81412414],
[33.36838531, 37.73390254, 33.0117654...672, 44.03386405, 43.67148673, 48.63067102],
[32.28830047, 30.15609296, 36.65741325, 35.73179981, 40.69098504]])
desired = array([[32.49418447, 44.26508328, 55.58324819, 50.90632842, 53.13241351],
[36.78467189, 42.32410703, 50.5137596...954, 51.93015205, 56.78985728, 63.23111802],
[26.45539443, 35.1080233 , 46.86066347, 49.16227375, 60.05539763]])
rtol = 1e-05, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-05, atol=1e-05
E
E Mismatched elements: 20 / 20 (100%)
E Max absolute difference: 19.36441258
E Max relative difference: 0.34647974
E x: array([[30.366597, 39.629756, 53.455653, 42.070115, 42.814124],
E [33.368385, 37.733903, 33.011765, 32.58301 , 39.999025],
E [18.994361, 35.440507, 44.033864, 43.671487, 48.630671],
E [32.2883 , 30.156093, 36.657413, 35.7318 , 40.690985]])
E y: array([[32.494184, 44.265083, 55.583248, 50.906328, 53.132414],
E [36.784672, 42.324107, 50.51376 , 43.278745, 49.956693],
E [22.164907, 37.049 , 51.930152, 56.789857, 63.231118],
E [26.455394, 35.108023, 46.860663, 49.162274, 60.055398]])

cupy/testing/_array.py:24: AssertionError

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_filters.TestGenericFilter object at 0x7f24ea38a3a0> parameter: {'filter'... 'numpy.float64'>, 'ksize': 4, 'mode': 'mirror', 'shape': (4, 5), 'function': <function rms_pyfunc at 0x7f25f5f744c0>}>
args = (), kw = {}
cupy_result = (array([[29.110215 , 29.71338479, 34.67394898, 25.2421024 , 31.8515699 ],
[ 0. , 0. , 0. ... , 0. , 0. , 0. ],
[ 0. , 0. , 0. , 0. , 0. ]]),)
cupy_error = None
numpy_result = (array([[39.92050807, 39.92050807, 51.40005714, 43.376314 , 54.85586307],
[39.92050807, 39.92050807, 51.400057...2, 44.98891502, 43.33693082, 53.99120362],
[33.21871236, 33.21871236, 48.82046921, 44.04305038, 59.64480722]]),)
numpy_error = None
cupy_numpy_result_ndarrays = [(array([[29.110215 , 29.71338479, 34.67394898, 25.2421024 , 31.8515699 ],
[ 0. , 0. , 0. ...2, 44.98891502, 43.33693082, 53.99120362],
[33.21871236, 33.21871236, 48.82046921, 44.04305038, 59.64480722]]))]
cupy_r = array([[29.110215 , 29.71338479, 34.67394898, 25.2421024 , 31.8515699 ],
[ 0. , 0. , 0. ... , 0. , 0. , 0. ],
[ 0. , 0. , 0. , 0. , 0. ]])
numpy_r = array([[39.92050807, 39.92050807, 51.40005714, 43.376314 , 54.85586307],
[39.92050807, 39.92050807, 51.4000571...222, 44.98891502, 43.33693082, 53.99120362],
[33.21871236, 33.21871236, 48.82046921, 44.04305038, 59.64480722]])
skip = False

@_wraps_partial_xp(impl, name, sp_name, scipy_name)
def test_func(self, *args, **kw):
# Run cupy and numpy
(
cupy_result, cupy_error,
numpy_result, numpy_error) = (
_call_func_numpy_cupy(
self, impl, args, kw, name, sp_name, scipy_name))
assert cupy_result is not None or cupy_error is not None
assert numpy_result is not None or numpy_error is not None

# Check errors raised
if cupy_error or numpy_error:
_check_cupy_numpy_error(cupy_error,
numpy_error,
accept_error=accept_error)
return

# Check returned arrays

if not isinstance(cupy_result, (tuple, list)):
cupy_result = cupy_result,
if not isinstance(numpy_result, (tuple, list)):
numpy_result = numpy_result,

assert len(cupy_result) == len(numpy_result)

# Check types
cupy_numpy_result_ndarrays = [
_convert_output_to_ndarray(
cupy_r, numpy_r, sp_name, check_sparse_format)
for cupy_r, numpy_r in zip(cupy_result, numpy_result)]

# Check dtypes
if type_check:
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
if cupy_r.dtype != numpy_r.dtype:
raise AssertionError(
'''ndarrays of different dtypes are returned.
cupy: {}
numpy: {}'''.format(cupy_r.dtype, numpy_r.dtype))

# Check contiguities
if contiguous_check:
for cupy_r, numpy_r in zip(cupy_result, numpy_result):
if isinstance(numpy_r, numpy.ndarray):
if (numpy_r.flags.c_contiguous
and not cupy_r.flags.c_contiguous):
raise AssertionError(
'The state of c_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.c_contiguous,
numpy_r.flags.c_contiguous))
if (numpy_r.flags.f_contiguous
and not cupy_r.flags.f_contiguous):
raise AssertionError(
'The state of f_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.f_contiguous,
numpy_r.flags.f_contiguous))

# Check shapes
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
assert cupy_r.shape == numpy_r.shape

# Check item values
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
# Behavior of assigning a negative value to an unsigned integer
# variable is undefined.
# nVidia GPUs and Intel CPUs behave differently.
# To avoid this difference, we need to ignore dimensions whose
# values are negative.

skip = False
if (_contains_signed_and_unsigned(kw)
and cupy_r.dtype in _unsigned_dtypes):
mask = _make_positive_mask(
self, impl, args, kw, name, sp_name, scipy_name)
if cupy_r.shape == ():
skip = (mask == 0).all()
else:
cupy_r = cupy_r[mask].get()
numpy_r = numpy_r[mask]

if not skip:
> check_func(cupy_r, numpy_r)

cupy/testing/_helper.py:343:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[29.110215 , 29.71338479, 34.67394898, 25.2421024 , 31.8515699 ],
[ 0. , 0. , 0. ... , 0. , 0. , 0. ],
[ 0. , 0. , 0. , 0. , 0. ]])
desired = array([[39.92050807, 39.92050807, 51.40005714, 43.376314 , 54.85586307],
[39.92050807, 39.92050807, 51.4000571...222, 44.98891502, 43.33693082, 53.99120362],
[33.21871236, 33.21871236, 48.82046921, 44.04305038, 59.64480722]])
rtol = 1e-05, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-05, atol=1e-05
E
E Mismatched elements: 20 / 20 (100%)
E Max absolute difference: 59.64480722
E Max relative difference: 1.
E x: array([[29.110215, 29.713385, 34.673949, 25.242102, 31.85157 ],
E [ 0. , 0. , 0. , 0. , 0. ],
E [ 0. , 0. , 0. , 0. , 0. ],
E [ 0. , 0. , 0. , 0. , 0. ]])
E y: array([[39.920508, 39.920508, 51.400057, 43.376314, 54.855863],
E [39.920508, 39.920508, 51.400057, 43.376314, 54.855863],
E [34.334642, 34.334642, 44.988915, 43.336931, 53.991204],
E [33.218712, 33.218712, 48.820469, 44.04305 , 59.644807]])

cupy/testing/_array.py:24: AssertionError

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_filters.TestGenericFilter object at 0x7f24ea25f2b0> parameter: {'filter'...s 'numpy.float64'>, 'ksize': 3, 'mode': 'mirror', 'shape': (4, 5), 'function': <function lt_pyfunc at 0x7f25f4cbad30>}>
args = (), kw = {}
cupy_result = (array([[4., 6., 3., 4., 3.],
[5., 7., 7., 5., 3.],
[6., 5., 4., 3., 2.],
[5., 7., 6., 4., 3.]]),)
cupy_error = None
numpy_result = (array([[4., 6., 3., 3., 2.],
[5., 0., 6., 8., 1.],
[8., 3., 3., 7., 0.],
[2., 0., 6., 4., 4.]]),)
numpy_error = None
cupy_numpy_result_ndarrays = [(array([[4., 6., 3., 4., 3.],
[5., 7., 7., 5., 3.],
[6., 5., 4., 3., 2.],
[5., 7., 6., 4., 3.]]), array([[4., 6., 3., 3., 2.],
[5., 0., 6., 8., 1.],
[8., 3., 3., 7., 0.],
[2., 0., 6., 4., 4.]]))]
cupy_r = array([[4., 6., 3., 4., 3.],
[5., 7., 7., 5., 3.],
[6., 5., 4., 3., 2.],
[5., 7., 6., 4., 3.]])
numpy_r = array([[4., 6., 3., 3., 2.],
[5., 0., 6., 8., 1.],
[8., 3., 3., 7., 0.],
[2., 0., 6., 4., 4.]])
skip = False

@_wraps_partial_xp(impl, name, sp_name, scipy_name)
def test_func(self, *args, **kw):
# Run cupy and numpy
(
cupy_result, cupy_error,
numpy_result, numpy_error) = (
_call_func_numpy_cupy(
self, impl, args, kw, name, sp_name, scipy_name))
assert cupy_result is not None or cupy_error is not None
assert numpy_result is not None or numpy_error is not None

# Check errors raised
if cupy_error or numpy_error:
_check_cupy_numpy_error(cupy_error,
numpy_error,
accept_error=accept_error)
return

# Check returned arrays

if not isinstance(cupy_result, (tuple, list)):
cupy_result = cupy_result,
if not isinstance(numpy_result, (tuple, list)):
numpy_result = numpy_result,

assert len(cupy_result) == len(numpy_result)

# Check types
cupy_numpy_result_ndarrays = [
_convert_output_to_ndarray(
cupy_r, numpy_r, sp_name, check_sparse_format)
for cupy_r, numpy_r in zip(cupy_result, numpy_result)]

# Check dtypes
if type_check:
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
if cupy_r.dtype != numpy_r.dtype:
raise AssertionError(
'''ndarrays of different dtypes are returned.
cupy: {}
numpy: {}'''.format(cupy_r.dtype, numpy_r.dtype))

# Check contiguities
if contiguous_check:
for cupy_r, numpy_r in zip(cupy_result, numpy_result):
if isinstance(numpy_r, numpy.ndarray):
if (numpy_r.flags.c_contiguous
and not cupy_r.flags.c_contiguous):
raise AssertionError(
'The state of c_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.c_contiguous,
numpy_r.flags.c_contiguous))
if (numpy_r.flags.f_contiguous
and not cupy_r.flags.f_contiguous):
raise AssertionError(
'The state of f_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.f_contiguous,
numpy_r.flags.f_contiguous))

# Check shapes
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
assert cupy_r.shape == numpy_r.shape

# Check item values
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
# Behavior of assigning a negative value to an unsigned integer
# variable is undefined.
# nVidia GPUs and Intel CPUs behave differently.
# To avoid this difference, we need to ignore dimensions whose
# values are negative.

skip = False
if (_contains_signed_and_unsigned(kw)
and cupy_r.dtype in _unsigned_dtypes):
mask = _make_positive_mask(
self, impl, args, kw, name, sp_name, scipy_name)
if cupy_r.shape == ():
skip = (mask == 0).all()
else:
cupy_r = cupy_r[mask].get()
numpy_r = numpy_r[mask]

if not skip:
> check_func(cupy_r, numpy_r)

cupy/testing/_helper.py:343:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[4., 6., 3., 4., 3.],
[5., 7., 7., 5., 3.],
[6., 5., 4., 3., 2.],
[5., 7., 6., 4., 3.]])
desired = array([[4., 6., 3., 3., 2.],
[5., 0., 6., 8., 1.],
[8., 3., 3., 7., 0.],
[2., 0., 6., 4., 4.]])
rtol = 1e-05, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-05, atol=1e-05
E
E Mismatched elements: 14 / 20 (70%)
E Max absolute difference: 7.
E Max relative difference: 2.
E x: array([[4., 6., 3., 4., 3.],
E [5., 7., 7., 5., 3.],
E [6., 5., 4., 3., 2.],
E [5., 7., 6., 4., 3.]])
E y: array([[4., 6., 3., 3., 2.],
E [5., 0., 6., 8., 1.],
E [8., 3., 3., 7., 0.],
E [2., 0., 6., 4., 4.]])

cupy/testing/_array.py:24: AssertionError

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_filters.TestGenericFilter object at 0x7f24e96dd5b0> parameter: {'filter'...s 'numpy.float64'>, 'ksize': 4, 'mode': 'mirror', 'shape': (4, 5), 'function': <function lt_pyfunc at 0x7f25f4cbad30>}>
args = (), kw = {}
cupy_result = (array([[15., 5., 13., 6., 9.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.]]),)
cupy_error = None
numpy_result = (array([[ 8., 11., 4., 10., 7.],
[14., 0., 7., 4., 8.],
[ 8., 5., 11., 5., 5.],
[14., 0., 1., 0., 7.]]),)
numpy_error = None
cupy_numpy_result_ndarrays = [(array([[15., 5., 13., 6., 9.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.],
[ 0., ...4., 10., 7.],
[14., 0., 7., 4., 8.],
[ 8., 5., 11., 5., 5.],
[14., 0., 1., 0., 7.]]))]
cupy_r = array([[15., 5., 13., 6., 9.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.]])
numpy_r = array([[ 8., 11., 4., 10., 7.],
[14., 0., 7., 4., 8.],
[ 8., 5., 11., 5., 5.],
[14., 0., 1., 0., 7.]])
skip = False

@_wraps_partial_xp(impl, name, sp_name, scipy_name)
def test_func(self, *args, **kw):
# Run cupy and numpy
(
cupy_result, cupy_error,
numpy_result, numpy_error) = (
_call_func_numpy_cupy(
self, impl, args, kw, name, sp_name, scipy_name))
assert cupy_result is not None or cupy_error is not None
assert numpy_result is not None or numpy_error is not None

# Check errors raised
if cupy_error or numpy_error:
_check_cupy_numpy_error(cupy_error,
numpy_error,
accept_error=accept_error)
return

# Check returned arrays

if not isinstance(cupy_result, (tuple, list)):
cupy_result = cupy_result,
if not isinstance(numpy_result, (tuple, list)):
numpy_result = numpy_result,

assert len(cupy_result) == len(numpy_result)

# Check types
cupy_numpy_result_ndarrays = [
_convert_output_to_ndarray(
cupy_r, numpy_r, sp_name, check_sparse_format)
for cupy_r, numpy_r in zip(cupy_result, numpy_result)]

# Check dtypes
if type_check:
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
if cupy_r.dtype != numpy_r.dtype:
raise AssertionError(
'''ndarrays of different dtypes are returned.
cupy: {}
numpy: {}'''.format(cupy_r.dtype, numpy_r.dtype))

# Check contiguities
if contiguous_check:
for cupy_r, numpy_r in zip(cupy_result, numpy_result):
if isinstance(numpy_r, numpy.ndarray):
if (numpy_r.flags.c_contiguous
and not cupy_r.flags.c_contiguous):
raise AssertionError(
'The state of c_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.c_contiguous,
numpy_r.flags.c_contiguous))
if (numpy_r.flags.f_contiguous
and not cupy_r.flags.f_contiguous):
raise AssertionError(
'The state of f_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.f_contiguous,
numpy_r.flags.f_contiguous))

# Check shapes
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
assert cupy_r.shape == numpy_r.shape

# Check item values
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
# Behavior of assigning a negative value to an unsigned integer
# variable is undefined.
# nVidia GPUs and Intel CPUs behave differently.
# To avoid this difference, we need to ignore dimensions whose
# values are negative.

skip = False
if (_contains_signed_and_unsigned(kw)
and cupy_r.dtype in _unsigned_dtypes):
mask = _make_positive_mask(
self, impl, args, kw, name, sp_name, scipy_name)
if cupy_r.shape == ():
skip = (mask == 0).all()
else:
cupy_r = cupy_r[mask].get()
numpy_r = numpy_r[mask]

if not skip:
> check_func(cupy_r, numpy_r)

cupy/testing/_helper.py:343:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[15., 5., 13., 6., 9.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.]])
desired = array([[ 8., 11., 4., 10., 7.],
[14., 0., 7., 4., 8.],
[ 8., 5., 11., 5., 5.],
[14., 0., 1., 0., 7.]])
rtol = 1e-05, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-05, atol=1e-05
E
E Mismatched elements: 17 / 20 (85%)
E Max absolute difference: 14.
E Max relative difference: 2.25
E x: array([[15., 5., 13., 6., 9.],
E [ 0., 0., 0., 0., 0.],
E [ 0., 0., 0., 0., 0.],
E [ 0., 0., 0., 0., 0.]])
E y: array([[ 8., 11., 4., 10., 7.],
E [14., 0., 7., 4., 8.],
E [ 8., 5., 11., 5., 5.],
E [14., 0., 1., 0., 7.]])

cupy/testing/_array.py:24: AssertionError

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_filters.TestGenericFilter object at 0x7f24e9ed1af0> parameter: {'filter'...ss 'numpy.uint8'>, 'ksize': 3, 'mode': 'mirror', 'shape': (4, 5), 'function': <function rms_pyfunc at 0x7f25f5f744c0>}>
args = (), kw = {}
cupy_result = (array([[21, 28, 45, 28, 29],
[28, 24, 27, 19, 21],
[14, 25, 40, 31, 32],
[28, 19, 33, 25, 26]], dtype=uint8),)
cupy_error = None
numpy_result = (array([[31, 36, 54, 42, 44],
[32, 37, 44, 33, 44],
[16, 36, 54, 41, 63],
[24, 30, 40, 45, 48]], dtype=uint8),)
numpy_error = None
cupy_numpy_result_ndarrays = [(array([[21, 28, 45, 28, 29],
[28, 24, 27, 19, 21],
[14, 25, 40, 31, 32],
[28, 19, 33, 25, 26]],...36, 54, 42, 44],
[32, 37, 44, 33, 44],
[16, 36, 54, 41, 63],
[24, 30, 40, 45, 48]], dtype=uint8))]
cupy_r = array([[21, 28, 45, 28, 29],
[28, 24, 27, 19, 21],
[14, 25, 40, 31, 32],
[28, 19, 33, 25, 26]], dtype=uint8)
numpy_r = array([[31, 36, 54, 42, 44],
[32, 37, 44, 33, 44],
[16, 36, 54, 41, 63],
[24, 30, 40, 45, 48]], dtype=uint8)
skip = False

@_wraps_partial_xp(impl, name, sp_name, scipy_name)
def test_func(self, *args, **kw):
# Run cupy and numpy
(
cupy_result, cupy_error,
numpy_result, numpy_error) = (
_call_func_numpy_cupy(
self, impl, args, kw, name, sp_name, scipy_name))
assert cupy_result is not None or cupy_error is not None
assert numpy_result is not None or numpy_error is not None

# Check errors raised
if cupy_error or numpy_error:
_check_cupy_numpy_error(cupy_error,
numpy_error,
accept_error=accept_error)
return

# Check returned arrays

if not isinstance(cupy_result, (tuple, list)):
cupy_result = cupy_result,
if not isinstance(numpy_result, (tuple, list)):
numpy_result = numpy_result,

assert len(cupy_result) == len(numpy_result)

# Check types
cupy_numpy_result_ndarrays = [
_convert_output_to_ndarray(
cupy_r, numpy_r, sp_name, check_sparse_format)
for cupy_r, numpy_r in zip(cupy_result, numpy_result)]

# Check dtypes
if type_check:
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
if cupy_r.dtype != numpy_r.dtype:
raise AssertionError(
'''ndarrays of different dtypes are returned.
cupy: {}
numpy: {}'''.format(cupy_r.dtype, numpy_r.dtype))

# Check contiguities
if contiguous_check:
for cupy_r, numpy_r in zip(cupy_result, numpy_result):
if isinstance(numpy_r, numpy.ndarray):
if (numpy_r.flags.c_contiguous
and not cupy_r.flags.c_contiguous):
raise AssertionError(
'The state of c_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.c_contiguous,
numpy_r.flags.c_contiguous))
if (numpy_r.flags.f_contiguous
and not cupy_r.flags.f_contiguous):
raise AssertionError(
'The state of f_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.f_contiguous,
numpy_r.flags.f_contiguous))

# Check shapes
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
assert cupy_r.shape == numpy_r.shape

# Check item values
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
# Behavior of assigning a negative value to an unsigned integer
# variable is undefined.
# nVidia GPUs and Intel CPUs behave differently.
# To avoid this difference, we need to ignore dimensions whose
# values are negative.

skip = False
if (_contains_signed_and_unsigned(kw)
and cupy_r.dtype in _unsigned_dtypes):
mask = _make_positive_mask(
self, impl, args, kw, name, sp_name, scipy_name)
if cupy_r.shape == ():
skip = (mask == 0).all()
else:
cupy_r = cupy_r[mask].get()
numpy_r = numpy_r[mask]

if not skip:
> check_func(cupy_r, numpy_r)

cupy/testing/_helper.py:343:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[21, 28, 45, 28, 29],
[28, 24, 27, 19, 21],
[14, 25, 40, 31, 32],
[28, 19, 33, 25, 26]], dtype=uint8)
desired = array([[31, 36, 54, 42, 44],
[32, 37, 44, 33, 44],
[16, 36, 54, 41, 63],
[24, 30, 40, 45, 48]], dtype=uint8)
rtol = 1e-05, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-05, atol=1e-05
E
E Mismatched elements: 20 / 20 (100%)
E Max absolute difference: 254
E Max relative difference: 15.875
E x: array([[21, 28, 45, 28, 29],
E [28, 24, 27, 19, 21],
E [14, 25, 40, 31, 32],
E [28, 19, 33, 25, 26]], dtype=uint8)
E y: array([[31, 36, 54, 42, 44],
E [32, 37, 44, 33, 44],
E [16, 36, 54, 41, 63],
E [24, 30, 40, 45, 48]], dtype=uint8)

cupy/testing/_array.py:24: AssertionError

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_filters.TestGenericFilter object at 0x7f24e8f350d0> parameter: {'filter'...ss 'numpy.uint8'>, 'ksize': 4, 'mode': 'mirror', 'shape': (4, 5), 'function': <function rms_pyfunc at 0x7f25f5f744c0>}>
args = (), kw = {}
cupy_result = (array([[23, 27, 36, 28, 53],
[ 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0]], dtype=uint8),)
cupy_error = None
numpy_result = (array([[31, 37, 37, 34, 51],
[36, 33, 47, 34, 49],
[32, 30, 35, 33, 43],
[26, 31, 44, 32, 61]], dtype=uint8),)
numpy_error = None
cupy_numpy_result_ndarrays = [(array([[23, 27, 36, 28, 53],
[ 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0]],...37, 37, 34, 51],
[36, 33, 47, 34, 49],
[32, 30, 35, 33, 43],
[26, 31, 44, 32, 61]], dtype=uint8))]
cupy_r = array([[23, 27, 36, 28, 53],
[ 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0]], dtype=uint8)
numpy_r = array([[31, 37, 37, 34, 51],
[36, 33, 47, 34, 49],
[32, 30, 35, 33, 43],
[26, 31, 44, 32, 61]], dtype=uint8)
skip = False

@_wraps_partial_xp(impl, name, sp_name, scipy_name)
def test_func(self, *args, **kw):
# Run cupy and numpy
(
cupy_result, cupy_error,
numpy_result, numpy_error) = (
_call_func_numpy_cupy(
self, impl, args, kw, name, sp_name, scipy_name))
assert cupy_result is not None or cupy_error is not None
assert numpy_result is not None or numpy_error is not None

# Check errors raised
if cupy_error or numpy_error:
_check_cupy_numpy_error(cupy_error,
numpy_error,
accept_error=accept_error)
return

# Check returned arrays

if not isinstance(cupy_result, (tuple, list)):
cupy_result = cupy_result,
if not isinstance(numpy_result, (tuple, list)):
numpy_result = numpy_result,

assert len(cupy_result) == len(numpy_result)

# Check types
cupy_numpy_result_ndarrays = [
_convert_output_to_ndarray(
cupy_r, numpy_r, sp_name, check_sparse_format)
for cupy_r, numpy_r in zip(cupy_result, numpy_result)]

# Check dtypes
if type_check:
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
if cupy_r.dtype != numpy_r.dtype:
raise AssertionError(
'''ndarrays of different dtypes are returned.
cupy: {}
numpy: {}'''.format(cupy_r.dtype, numpy_r.dtype))

# Check contiguities
if contiguous_check:
for cupy_r, numpy_r in zip(cupy_result, numpy_result):
if isinstance(numpy_r, numpy.ndarray):
if (numpy_r.flags.c_contiguous
and not cupy_r.flags.c_contiguous):
raise AssertionError(
'The state of c_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.c_contiguous,
numpy_r.flags.c_contiguous))
if (numpy_r.flags.f_contiguous
and not cupy_r.flags.f_contiguous):
raise AssertionError(
'The state of f_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.f_contiguous,
numpy_r.flags.f_contiguous))

# Check shapes
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
assert cupy_r.shape == numpy_r.shape

# Check item values
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
# Behavior of assigning a negative value to an unsigned integer
# variable is undefined.
# nVidia GPUs and Intel CPUs behave differently.
# To avoid this difference, we need to ignore dimensions whose
# values are negative.

skip = False
if (_contains_signed_and_unsigned(kw)
and cupy_r.dtype in _unsigned_dtypes):
mask = _make_positive_mask(
self, impl, args, kw, name, sp_name, scipy_name)
if cupy_r.shape == ():
skip = (mask == 0).all()
else:
cupy_r = cupy_r[mask].get()
numpy_r = numpy_r[mask]

if not skip:
> check_func(cupy_r, numpy_r)

cupy/testing/_helper.py:343:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[23, 27, 36, 28, 53],
[ 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0]], dtype=uint8)
desired = array([[31, 37, 37, 34, 51],
[36, 33, 47, 34, 49],
[32, 30, 35, 33, 43],
[26, 31, 44, 32, 61]], dtype=uint8)
rtol = 1e-05, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-05, atol=1e-05
E
E Mismatched elements: 20 / 20 (100%)
E Max absolute difference: 255
E Max relative difference: 8.84615385
E x: array([[23, 27, 36, 28, 53],
E [ 0, 0, 0, 0, 0],
E [ 0, 0, 0, 0, 0],
E [ 0, 0, 0, 0, 0]], dtype=uint8)
E y: array([[31, 37, 37, 34, 51],
E [36, 33, 47, 34, 49],
E [32, 30, 35, 33, 43],
E [26, 31, 44, 32, 61]], dtype=uint8)

cupy/testing/_array.py:24: AssertionError

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_filters.TestGenericFilter object at 0x7f24e93860a0> parameter: {'filter'... 'numpy.float64'>, 'ksize': 3, 'mode': 'mirror', 'shape': (4, 5), 'function': <function rms_pyfunc at 0x7f25f5f744c0>}>
args = (), kw = {}
cupy_result = (array([[32.00449826, 37.68575782, 60.8028936 , 38.48790895, 39.21631239],
[34.60326543, 32.2532409 , 33.257219...9, 51.41878991, 42.0040045 , 51.31070106],
[33.21458492, 22.51034287, 37.94448098, 37.08985252, 37.51394469]]),)
cupy_error = None
numpy_result = (array([[34.73996818, 43.64546371, 63.5383726 , 49.84875414, 52.48268444],
[37.33873469, 42.72655042, 49.589277...5, 62.15186111, 50.87288873, 72.5746653 ],
[29.90948782, 36.17835396, 46.34962956, 49.94860122, 54.16193588]]),)
numpy_error = None
cupy_numpy_result_ndarrays = [(array([[32.00449826, 37.68575782, 60.8028936 , 38.48790895, 39.21631239],
[34.60326543, 32.2532409 , 33.25721...5, 62.15186111, 50.87288873, 72.5746653 ],
[29.90948782, 36.17835396, 46.34962956, 49.94860122, 54.16193588]]))]
cupy_r = array([[32.00449826, 37.68575782, 60.8028936 , 38.48790895, 39.21631239],
[34.60326543, 32.2532409 , 33.2572195...229, 51.41878991, 42.0040045 , 51.31070106],
[33.21458492, 22.51034287, 37.94448098, 37.08985252, 37.51394469]])
numpy_r = array([[34.73996818, 43.64546371, 63.5383726 , 49.84875414, 52.48268444],
[37.33873469, 42.72655042, 49.5892777...725, 62.15186111, 50.87288873, 72.5746653 ],
[29.90948782, 36.17835396, 46.34962956, 49.94860122, 54.16193588]])
skip = False

@_wraps_partial_xp(impl, name, sp_name, scipy_name)
def test_func(self, *args, **kw):
# Run cupy and numpy
(
cupy_result, cupy_error,
numpy_result, numpy_error) = (
_call_func_numpy_cupy(
self, impl, args, kw, name, sp_name, scipy_name))
assert cupy_result is not None or cupy_error is not None
assert numpy_result is not None or numpy_error is not None

# Check errors raised
if cupy_error or numpy_error:
_check_cupy_numpy_error(cupy_error,
numpy_error,
accept_error=accept_error)
return

# Check returned arrays

if not isinstance(cupy_result, (tuple, list)):
cupy_result = cupy_result,
if not isinstance(numpy_result, (tuple, list)):
numpy_result = numpy_result,

assert len(cupy_result) == len(numpy_result)

# Check types
cupy_numpy_result_ndarrays = [
_convert_output_to_ndarray(
cupy_r, numpy_r, sp_name, check_sparse_format)
for cupy_r, numpy_r in zip(cupy_result, numpy_result)]

# Check dtypes
if type_check:
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
if cupy_r.dtype != numpy_r.dtype:
raise AssertionError(
'''ndarrays of different dtypes are returned.
cupy: {}
numpy: {}'''.format(cupy_r.dtype, numpy_r.dtype))

# Check contiguities
if contiguous_check:
for cupy_r, numpy_r in zip(cupy_result, numpy_result):
if isinstance(numpy_r, numpy.ndarray):
if (numpy_r.flags.c_contiguous
and not cupy_r.flags.c_contiguous):
raise AssertionError(
'The state of c_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.c_contiguous,
numpy_r.flags.c_contiguous))
if (numpy_r.flags.f_contiguous
and not cupy_r.flags.f_contiguous):
raise AssertionError(
'The state of f_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.f_contiguous,
numpy_r.flags.f_contiguous))

# Check shapes
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
assert cupy_r.shape == numpy_r.shape

# Check item values
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
# Behavior of assigning a negative value to an unsigned integer
# variable is undefined.
# nVidia GPUs and Intel CPUs behave differently.
# To avoid this difference, we need to ignore dimensions whose
# values are negative.

skip = False
if (_contains_signed_and_unsigned(kw)
and cupy_r.dtype in _unsigned_dtypes):
mask = _make_positive_mask(
self, impl, args, kw, name, sp_name, scipy_name)
if cupy_r.shape == ():
skip = (mask == 0).all()
else:
cupy_r = cupy_r[mask].get()
numpy_r = numpy_r[mask]

if not skip:
> check_func(cupy_r, numpy_r)

cupy/testing/_helper.py:343:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[32.00449826, 37.68575782, 60.8028936 , 38.48790895, 39.21631239],
[34.60326543, 32.2532409 , 33.2572195...229, 51.41878991, 42.0040045 , 51.31070106],
[33.21458492, 22.51034287, 37.94448098, 37.08985252, 37.51394469]])
desired = array([[34.73996818, 43.64546371, 63.5383726 , 49.84875414, 52.48268444],
[37.33873469, 42.72655042, 49.5892777...725, 62.15186111, 50.87288873, 72.5746653 ],
[29.90948782, 36.17835396, 46.34962956, 49.94860122, 54.16193588]])
rtol = 1e-05, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-05, atol=1e-05
E
E Mismatched elements: 20 / 20 (100%)
E Max absolute difference: 21.26396424
E Max relative difference: 0.37779527
E x: array([[32.004498, 37.685758, 60.802894, 38.487909, 39.216312],
E [34.603265, 32.253241, 33.25722 , 33.041408, 36.624282],
E [20.112677, 38.150832, 51.41879 , 42.004005, 51.310701],
E [33.214585, 22.510343, 37.944481, 37.089853, 37.513945]])
E y: array([[34.739968, 43.645464, 63.538373, 49.848754, 52.482684],
E [37.338735, 42.72655 , 49.589278, 37.768093, 49.890655],
E [19.537204, 43.529837, 62.151861, 50.872889, 72.574665],
E [29.909488, 36.178354, 46.34963 , 49.948601, 54.161936]])

cupy/testing/_array.py:24: AssertionError

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_filters.TestGenericFilter object at 0x7f24e9ef5190> parameter: {'filter'... 'numpy.float64'>, 'ksize': 4, 'mode': 'mirror', 'shape': (4, 5), 'function': <function rms_pyfunc at 0x7f25f5f744c0>}>
args = (), kw = {}
cupy_result = (array([[24.21149428, 29.80534893, 37.32798429, 32.88328106, 46.48912698],
[ 0. , 0. , 0. ... , 0. , 0. , 0. ],
[ 0. , 0. , 0. , 0. , 0. ]]),)
cupy_error = None
numpy_result = (array([[36.86077635, 42.87616583, 43.41972747, 39.82804323, 58.74618737],
[42.04291274, 39.49732697, 56.260026...8, 40.06613219, 37.53324325, 49.79207175],
[31.44112421, 37.6867121 , 51.65417609, 39.59452747, 70.43768385]]),)
numpy_error = None
cupy_numpy_result_ndarrays = [(array([[24.21149428, 29.80534893, 37.32798429, 32.88328106, 46.48912698],
[ 0. , 0. , 0. ...8, 40.06613219, 37.53324325, 49.79207175],
[31.44112421, 37.6867121 , 51.65417609, 39.59452747, 70.43768385]]))]
cupy_r = array([[24.21149428, 29.80534893, 37.32798429, 32.88328106, 46.48912698],
[ 0. , 0. , 0. ... , 0. , 0. , 0. ],
[ 0. , 0. , 0. , 0. , 0. ]])
numpy_r = array([[36.86077635, 42.87616583, 43.41972747, 39.82804323, 58.74618737],
[42.04291274, 39.49732697, 56.2600260...358, 40.06613219, 37.53324325, 49.79207175],
[31.44112421, 37.6867121 , 51.65417609, 39.59452747, 70.43768385]])
skip = False

@_wraps_partial_xp(impl, name, sp_name, scipy_name)
def test_func(self, *args, **kw):
# Run cupy and numpy
(
cupy_result, cupy_error,
numpy_result, numpy_error) = (
_call_func_numpy_cupy(
self, impl, args, kw, name, sp_name, scipy_name))
assert cupy_result is not None or cupy_error is not None
assert numpy_result is not None or numpy_error is not None

# Check errors raised
if cupy_error or numpy_error:
_check_cupy_numpy_error(cupy_error,
numpy_error,
accept_error=accept_error)
return

# Check returned arrays

if not isinstance(cupy_result, (tuple, list)):
cupy_result = cupy_result,
if not isinstance(numpy_result, (tuple, list)):
numpy_result = numpy_result,

assert len(cupy_result) == len(numpy_result)

# Check types
cupy_numpy_result_ndarrays = [
_convert_output_to_ndarray(
cupy_r, numpy_r, sp_name, check_sparse_format)
for cupy_r, numpy_r in zip(cupy_result, numpy_result)]

# Check dtypes
if type_check:
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
if cupy_r.dtype != numpy_r.dtype:
raise AssertionError(
'''ndarrays of different dtypes are returned.
cupy: {}
numpy: {}'''.format(cupy_r.dtype, numpy_r.dtype))

# Check contiguities
if contiguous_check:
for cupy_r, numpy_r in zip(cupy_result, numpy_result):
if isinstance(numpy_r, numpy.ndarray):
if (numpy_r.flags.c_contiguous
and not cupy_r.flags.c_contiguous):
raise AssertionError(
'The state of c_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.c_contiguous,
numpy_r.flags.c_contiguous))
if (numpy_r.flags.f_contiguous
and not cupy_r.flags.f_contiguous):
raise AssertionError(
'The state of f_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.f_contiguous,
numpy_r.flags.f_contiguous))

# Check shapes
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
assert cupy_r.shape == numpy_r.shape

# Check item values
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
# Behavior of assigning a negative value to an unsigned integer
# variable is undefined.
# nVidia GPUs and Intel CPUs behave differently.
# To avoid this difference, we need to ignore dimensions whose
# values are negative.

skip = False
if (_contains_signed_and_unsigned(kw)
and cupy_r.dtype in _unsigned_dtypes):
mask = _make_positive_mask(
self, impl, args, kw, name, sp_name, scipy_name)
if cupy_r.shape == ():
skip = (mask == 0).all()
else:
cupy_r = cupy_r[mask].get()
numpy_r = numpy_r[mask]

if not skip:
> check_func(cupy_r, numpy_r)

cupy/testing/_helper.py:343:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[24.21149428, 29.80534893, 37.32798429, 32.88328106, 46.48912698],
[ 0. , 0. , 0. ... , 0. , 0. , 0. ],
[ 0. , 0. , 0. , 0. , 0. ]])
desired = array([[36.86077635, 42.87616583, 43.41972747, 39.82804323, 58.74618737],
[42.04291274, 39.49732697, 56.2600260...358, 40.06613219, 37.53324325, 49.79207175],
[31.44112421, 37.6867121 , 51.65417609, 39.59452747, 70.43768385]])
rtol = 1e-05, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-05, atol=1e-05
E
E Mismatched elements: 20 / 20 (100%)
E Max absolute difference: 70.43768385
E Max relative difference: 1.
E x: array([[24.211494, 29.805349, 37.327984, 32.883281, 46.489127],
E [ 0. , 0. , 0. , 0. , 0. ],
E [ 0. , 0. , 0. , 0. , 0. ],
E [ 0. , 0. , 0. , 0. , 0. ]])
E y: array([[36.860776, 42.876166, 43.419727, 39.828043, 58.746187],
E [42.042913, 39.497327, 56.260026, 40.67984 , 58.57918 ],
E [36.303403, 34.455314, 40.066132, 37.533243, 49.792072],
E [31.441124, 37.686712, 51.654176, 39.594527, 70.437684]])

cupy/testing/_array.py:24: AssertionError

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_filters.TestGenericFilter object at 0x7f24e8bb02b0> parameter: {'filter'...s 'numpy.float64'>, 'ksize': 3, 'mode': 'mirror', 'shape': (4, 5), 'function': <function lt_pyfunc at 0x7f25f4cbad30>}>
args = (), kw = {}
cupy_result = (array([[5., 3., 2., 4., 3.],
[1., 5., 1., 5., 6.],
[4., 4., 1., 3., 5.],
[1., 1., 1., 4., 4.]]),)
cupy_error = None
numpy_result = (array([[5., 2., 2., 3., 2.],
[0., 4., 0., 5., 5.],
[4., 4., 1., 2., 3.],
[0., 0., 0., 3., 2.]]),)
numpy_error = None
cupy_numpy_result_ndarrays = [(array([[5., 3., 2., 4., 3.],
[1., 5., 1., 5., 6.],
[4., 4., 1., 3., 5.],
[1., 1., 1., 4., 4.]]), array([[5., 2., 2., 3., 2.],
[0., 4., 0., 5., 5.],
[4., 4., 1., 2., 3.],
[0., 0., 0., 3., 2.]]))]
cupy_r = array([[5., 3., 2., 4., 3.],
[1., 5., 1., 5., 6.],
[4., 4., 1., 3., 5.],
[1., 1., 1., 4., 4.]])
numpy_r = array([[5., 2., 2., 3., 2.],
[0., 4., 0., 5., 5.],
[4., 4., 1., 2., 3.],
[0., 0., 0., 3., 2.]])
skip = False

@_wraps_partial_xp(impl, name, sp_name, scipy_name)
def test_func(self, *args, **kw):
# Run cupy and numpy
(
cupy_result, cupy_error,
numpy_result, numpy_error) = (
_call_func_numpy_cupy(
self, impl, args, kw, name, sp_name, scipy_name))
assert cupy_result is not None or cupy_error is not None
assert numpy_result is not None or numpy_error is not None

# Check errors raised
if cupy_error or numpy_error:
_check_cupy_numpy_error(cupy_error,
numpy_error,
accept_error=accept_error)
return

# Check returned arrays

if not isinstance(cupy_result, (tuple, list)):
cupy_result = cupy_result,
if not isinstance(numpy_result, (tuple, list)):
numpy_result = numpy_result,

assert len(cupy_result) == len(numpy_result)

# Check types
cupy_numpy_result_ndarrays = [
_convert_output_to_ndarray(
cupy_r, numpy_r, sp_name, check_sparse_format)
for cupy_r, numpy_r in zip(cupy_result, numpy_result)]

# Check dtypes
if type_check:
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
if cupy_r.dtype != numpy_r.dtype:
raise AssertionError(
'''ndarrays of different dtypes are returned.
cupy: {}
numpy: {}'''.format(cupy_r.dtype, numpy_r.dtype))

# Check contiguities
if contiguous_check:
for cupy_r, numpy_r in zip(cupy_result, numpy_result):
if isinstance(numpy_r, numpy.ndarray):
if (numpy_r.flags.c_contiguous
and not cupy_r.flags.c_contiguous):
raise AssertionError(
'The state of c_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.c_contiguous,
numpy_r.flags.c_contiguous))
if (numpy_r.flags.f_contiguous
and not cupy_r.flags.f_contiguous):
raise AssertionError(
'The state of f_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.f_contiguous,
numpy_r.flags.f_contiguous))

# Check shapes
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
assert cupy_r.shape == numpy_r.shape

# Check item values
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
# Behavior of assigning a negative value to an unsigned integer
# variable is undefined.
# nVidia GPUs and Intel CPUs behave differently.
# To avoid this difference, we need to ignore dimensions whose
# values are negative.

skip = False
if (_contains_signed_and_unsigned(kw)
and cupy_r.dtype in _unsigned_dtypes):
mask = _make_positive_mask(
self, impl, args, kw, name, sp_name, scipy_name)
if cupy_r.shape == ():
skip = (mask == 0).all()
else:
cupy_r = cupy_r[mask].get()
numpy_r = numpy_r[mask]

if not skip:
> check_func(cupy_r, numpy_r)

cupy/testing/_helper.py:343:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[5., 3., 2., 4., 3.],
[1., 5., 1., 5., 6.],
[4., 4., 1., 3., 5.],
[1., 1., 1., 4., 4.]])
desired = array([[5., 2., 2., 3., 2.],
[0., 4., 0., 5., 5.],
[4., 4., 1., 2., 3.],
[0., 0., 0., 3., 2.]])
rtol = 1e-05, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-05, atol=1e-05
E
E Mismatched elements: 14 / 20 (70%)
E Max absolute difference: 2.
E Max relative difference: 1.
E x: array([[5., 3., 2., 4., 3.],
E [1., 5., 1., 5., 6.],
E [4., 4., 1., 3., 5.],
E [1., 1., 1., 4., 4.]])
E y: array([[5., 2., 2., 3., 2.],
E [0., 4., 0., 5., 5.],
E [4., 4., 1., 2., 3.],
E [0., 0., 0., 3., 2.]])

cupy/testing/_array.py:24: AssertionError

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_filters.TestGenericFilter object at 0x7f24e8359490> parameter: {'filter'...s 'numpy.float64'>, 'ksize': 4, 'mode': 'mirror', 'shape': (4, 5), 'function': <function lt_pyfunc at 0x7f25f4cbad30>}>
args = (), kw = {}
cupy_result = (array([[ 6., 10., 10., 3., 9.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.]]),)
cupy_error = None
numpy_result = (array([[ 0., 10., 10., 1., 8.],
[ 7., 6., 2., 2., 2.],
[ 1., 10., 10., 2., 9.],
[ 4., 5., 9., 1., 6.]]),)
numpy_error = None
cupy_numpy_result_ndarrays = [(array([[ 6., 10., 10., 3., 9.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.],
[ 0., ...0., 1., 8.],
[ 7., 6., 2., 2., 2.],
[ 1., 10., 10., 2., 9.],
[ 4., 5., 9., 1., 6.]]))]
cupy_r = array([[ 6., 10., 10., 3., 9.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.]])
numpy_r = array([[ 0., 10., 10., 1., 8.],
[ 7., 6., 2., 2., 2.],
[ 1., 10., 10., 2., 9.],
[ 4., 5., 9., 1., 6.]])
skip = False

@_wraps_partial_xp(impl, name, sp_name, scipy_name)
def test_func(self, *args, **kw):
# Run cupy and numpy
(
cupy_result, cupy_error,
numpy_result, numpy_error) = (
_call_func_numpy_cupy(
self, impl, args, kw, name, sp_name, scipy_name))
assert cupy_result is not None or cupy_error is not None
assert numpy_result is not None or numpy_error is not None

# Check errors raised
if cupy_error or numpy_error:
_check_cupy_numpy_error(cupy_error,
numpy_error,
accept_error=accept_error)
return

# Check returned arrays

if not isinstance(cupy_result, (tuple, list)):
cupy_result = cupy_result,
if not isinstance(numpy_result, (tuple, list)):
numpy_result = numpy_result,

assert len(cupy_result) == len(numpy_result)

# Check types
cupy_numpy_result_ndarrays = [
_convert_output_to_ndarray(
cupy_r, numpy_r, sp_name, check_sparse_format)
for cupy_r, numpy_r in zip(cupy_result, numpy_result)]

# Check dtypes
if type_check:
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
if cupy_r.dtype != numpy_r.dtype:
raise AssertionError(
'''ndarrays of different dtypes are returned.
cupy: {}
numpy: {}'''.format(cupy_r.dtype, numpy_r.dtype))

# Check contiguities
if contiguous_check:
for cupy_r, numpy_r in zip(cupy_result, numpy_result):
if isinstance(numpy_r, numpy.ndarray):
if (numpy_r.flags.c_contiguous
and not cupy_r.flags.c_contiguous):
raise AssertionError(
'The state of c_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.c_contiguous,
numpy_r.flags.c_contiguous))
if (numpy_r.flags.f_contiguous
and not cupy_r.flags.f_contiguous):
raise AssertionError(
'The state of f_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.f_contiguous,
numpy_r.flags.f_contiguous))

# Check shapes
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
assert cupy_r.shape == numpy_r.shape

# Check item values
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
# Behavior of assigning a negative value to an unsigned integer
# variable is undefined.
# nVidia GPUs and Intel CPUs behave differently.
# To avoid this difference, we need to ignore dimensions whose
# values are negative.

skip = False
if (_contains_signed_and_unsigned(kw)
and cupy_r.dtype in _unsigned_dtypes):
mask = _make_positive_mask(
self, impl, args, kw, name, sp_name, scipy_name)
if cupy_r.shape == ():
skip = (mask == 0).all()
else:
cupy_r = cupy_r[mask].get()
numpy_r = numpy_r[mask]

if not skip:
> check_func(cupy_r, numpy_r)

cupy/testing/_helper.py:343:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 6., 10., 10., 3., 9.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.]])
desired = array([[ 0., 10., 10., 1., 8.],
[ 7., 6., 2., 2., 2.],
[ 1., 10., 10., 2., 9.],
[ 4., 5., 9., 1., 6.]])
rtol = 1e-05, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-05, atol=1e-05
E
E Mismatched elements: 18 / 20 (90%)
E Max absolute difference: 10.
E Max relative difference: 2.
E x: array([[ 6., 10., 10., 3., 9.],
E [ 0., 0., 0., 0., 0.],
E [ 0., 0., 0., 0., 0.],
E [ 0., 0., 0., 0., 0.]])
E y: array([[ 0., 10., 10., 1., 8.],
E [ 7., 6., 2., 2., 2.],
E [ 1., 10., 10., 2., 9.],
E [ 4., 5., 9., 1., 6.]])

cupy/testing/_array.py:24: AssertionError

self = <<cupyx_tests.scipy_tests.ndimage_tests.test_measurements.TestMeasurementsSelect object at 0x7f24d6a179d0> parameter: {'enable_cub': False, 'index': 1, 'labels': 50, 'op': 'extrema', 'shape': (32, 64)}>
args = (), kw = {'dtype': <class 'numpy.float32'>}
dtype = <class 'numpy.float32'>

@_wraps_partial(impl, name)
def test_func(self, *args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(self, *args, **kw)

cupy/testing/_helper.py:825:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:343: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:495: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([ 1, 11]), desired = array([ 1, 11]), rtol = 1e-07, atol = 0
err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=0
E
E Mismatched elements: 1 / 2 (50%)
E Max absolute difference: 1125
E Max relative difference: 1125.
E x: array([1126, 11])
E y: array([ 1, 11])

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.float32'>